2618 lines
94 KiB
Java
2618 lines
94 KiB
Java
package app;
|
|
|
|
import java.awt.BorderLayout;
|
|
import java.awt.Color;
|
|
import java.awt.Desktop;
|
|
import java.awt.Dimension;
|
|
import java.awt.Font;
|
|
import java.awt.event.ActionEvent;
|
|
import java.awt.event.KeyEvent;
|
|
import java.awt.event.MouseAdapter;
|
|
import java.awt.event.MouseEvent;
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.util.Enumeration;
|
|
import java.util.regex.Matcher;
|
|
import java.util.regex.Pattern;
|
|
import javax.swing.AbstractAction;
|
|
import javax.swing.Action;
|
|
import javax.swing.ImageIcon;
|
|
import javax.swing.JButton;
|
|
import javax.swing.JFileChooser;
|
|
import javax.swing.JFrame;
|
|
import javax.swing.JMenu;
|
|
import javax.swing.JMenuBar;
|
|
import javax.swing.JOptionPane;
|
|
import javax.swing.JPanel;
|
|
import javax.swing.JPopupMenu;
|
|
import javax.swing.JScrollPane;
|
|
import javax.swing.JSplitPane;
|
|
import javax.swing.JToolBar;
|
|
import javax.swing.JTree;
|
|
import javax.swing.KeyStroke;
|
|
import javax.swing.UnsupportedLookAndFeelException;
|
|
import javax.swing.filechooser.FileNameExtensionFilter;
|
|
import javax.swing.tree.DefaultMutableTreeNode;
|
|
import javax.swing.tree.DefaultTreeCellRenderer;
|
|
import javax.swing.tree.TreeNode;
|
|
import javax.swing.tree.TreePath;
|
|
import javax.swing.tree.TreeSelectionModel;
|
|
import javax.xml.parsers.ParserConfigurationException;
|
|
import org.xml.sax.SAXException;
|
|
import MEPTL.commandes;
|
|
import MEPTL.ecritureSujet;
|
|
import MEPTL.meptl;
|
|
import MEPTL.verificationFichierAnalyse;
|
|
import cXML.Run;
|
|
import cXML.node;
|
|
import calcul.listeAttributsAnalyseWriter;
|
|
import calcul.listeNodeFormatageDirectDeWriter;
|
|
|
|
import java.awt.event.InputEvent;
|
|
import javax.swing.JToggleButton;
|
|
import java.awt.event.ActionListener;
|
|
|
|
|
|
public class create extends JFrame {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
// les élément de create
|
|
private JTree tree = new JTree();
|
|
private afficheText textNodeSelect = new afficheText();
|
|
private JToolBar toolBar_1;
|
|
private JMenuBar menuBar = new JMenuBar();
|
|
JButton buttonEvaluate;
|
|
TreePath cheminVersLeNode;
|
|
JToggleButton tglbtnTousLesNodes;
|
|
|
|
/**
|
|
* Create the application.
|
|
*/
|
|
public create() {
|
|
try {
|
|
initialize();
|
|
} catch (UnsupportedLookAndFeelException e) {
|
|
e.printStackTrace();
|
|
}
|
|
setVisible(true);
|
|
}
|
|
|
|
/**
|
|
* Initialize the contents of the frame.
|
|
* @throws UnsupportedLookAndFeelException
|
|
*/
|
|
private void initialize() throws UnsupportedLookAndFeelException {
|
|
|
|
setSize(1200,800);
|
|
int screenWidth = (int) java.awt.GraphicsEnvironment.getLocalGraphicsEnvironment().getMaximumWindowBounds().getWidth();
|
|
int screenHeight = (int) java.awt.GraphicsEnvironment.getLocalGraphicsEnvironment().getMaximumWindowBounds().getHeight();
|
|
setLocation(( (screenWidth) - getWidth()) / 2, (screenHeight - getHeight()) / 2);
|
|
|
|
ImageIcon img = new ImageIcon(getClass().getResource("/evalwriter.png") );
|
|
setTitle(commandes.Titre + " " + commandes.version + " " + commandes.branch);
|
|
setIconImage(img.getImage());
|
|
|
|
setLocationRelativeTo( null );
|
|
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
|
|
|
|
// Construction et injection de la barre de menu
|
|
setJMenuBar( this.createMenuBar() );
|
|
tree.setVisibleRowCount(30);
|
|
|
|
// Ajoute le menu contextuel de la tree
|
|
tree.setComponentPopupMenu(null);
|
|
|
|
// Construction et injection de la barre d'outils
|
|
JPanel contentPane = (JPanel) getContentPane();
|
|
this.createToolBar();
|
|
this.createPopupMenuTree(null);
|
|
getContentPane().setLayout(new BorderLayout(2, 2));
|
|
contentPane.add( toolBar_1, BorderLayout.NORTH );
|
|
|
|
|
|
// The content of the window
|
|
if(commandes.fichierAnalyseValide) tree = commandes.tree;
|
|
|
|
JScrollPane leftScrollPane = new JScrollPane( );
|
|
leftScrollPane.setPreferredSize( new Dimension(400, 0) );
|
|
JScrollPane rightScrollPane = new JScrollPane( );
|
|
|
|
JSplitPane splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, leftScrollPane, rightScrollPane );
|
|
splitPane.setBounds(10, 10, 1364, 783);
|
|
rightScrollPane.setViewportView(textNodeSelect);
|
|
textNodeSelect.setFont(new Font("Monospaced", Font.PLAIN, 15));
|
|
|
|
leftScrollPane.setViewportView(tree);
|
|
tree.setFont(new Font("Tahoma", Font.PLAIN, 14));
|
|
|
|
getContentPane().add(splitPane, BorderLayout.CENTER);
|
|
|
|
if(commandes.fichierAnalyseValide) constructionTree();
|
|
|
|
this.setExtendedState(MAXIMIZED_BOTH);
|
|
|
|
ListenerAction();
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
private void ListenerAction() {
|
|
|
|
tree.addMouseListener(new MouseAdapter() {
|
|
@Override
|
|
public void mouseClicked(MouseEvent e) {
|
|
if(tree.getSelectionPath()!=null) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
node nod = (node) selectNode.getUserObject();
|
|
createPopupMenuTree(nod);
|
|
textNodeSelect.refreshAffichage(nod);
|
|
}
|
|
}
|
|
});
|
|
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Calcul le total des points dans le node et les nodes enfants.
|
|
* @param nod
|
|
* @param point
|
|
* @return
|
|
*/
|
|
private int calculNombreDepoint(node nod, int point) {
|
|
System.out.println("début du calcul du nombre de point du node" + nod.getNomElt());
|
|
if(nod.getAttributs().get("evaluer")!=null) if(nod.getAttributs().get("evaluer").equalsIgnoreCase("true")){
|
|
if(nod.getAttributs().get("allContent")!=null) {
|
|
Pattern pt = Pattern.compile("[0-9]{1,}$");
|
|
Matcher match= pt.matcher(nod.getAttributs().get("allContent"));
|
|
if(match.find()) {
|
|
String s= match.group();
|
|
try {
|
|
point = point + Integer.valueOf(s);
|
|
} catch (Exception e) {
|
|
JOptionPane.showInternalMessageDialog(null, "Erreur dans la valeur de l'attribut allContent");
|
|
}
|
|
System.out.println("match point pour allcontent = " + s);
|
|
}
|
|
}
|
|
|
|
if(nod.getAttributs().get("evalNameInitialCreator")!=null) {
|
|
try {
|
|
point = point + Integer.valueOf(nod.getAttributs().get("evalNameInitialCreator"));
|
|
} catch (Exception e) {
|
|
JOptionPane.showInternalMessageDialog(null, "Erreur dans la valeur de l'attribut evalNameInitialCreator");
|
|
}
|
|
}
|
|
|
|
if(nod.getAttributs().get("evalNameCreator")!=null) {
|
|
try {
|
|
point = point + Integer.valueOf(nod.getAttributs().get("evalNameCreator"));
|
|
} catch (Exception e) {
|
|
JOptionPane.showInternalMessageDialog(null, "Erreur dans la valeur de l'attribut evalNameCreator");
|
|
}
|
|
}
|
|
|
|
if(nod.getAttributs().get("evalNameNode")!=null) {
|
|
try {
|
|
point = point + Integer.valueOf(nod.getAttributs().get("evalNameNode"));
|
|
} catch (Exception e) {
|
|
JOptionPane.showInternalMessageDialog(null, "Erreur dans la valeur de l'attribut evalNameCreator");
|
|
}
|
|
}
|
|
|
|
Enumeration<String> key = nod.getAttributs().keys();
|
|
while(key.hasMoreElements()) {
|
|
String k = key.nextElement();
|
|
if(nod.getAttributs().get(k).contains("‽")||nod.getAttributs().get(k).contains("‼")) {
|
|
Pattern pt = Pattern.compile("[0-9]{1,}$");
|
|
Matcher match= pt.matcher(nod.getAttributs().get(k));
|
|
if(match.find()) {
|
|
String s= match.group();
|
|
try {
|
|
point = point + Integer.valueOf(s);
|
|
} catch (Exception e) {
|
|
JOptionPane.showInternalMessageDialog(null, "Erreur dans la valeur de l'attribut "+ k);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
for(int i = 0 ; i < nod.getNodes().size();i++) {
|
|
if(nod.getNodes().get(i)!=null) {
|
|
point = calculNombreDepoint(nod.getNodes().get(i), point);
|
|
}
|
|
}
|
|
}
|
|
return point;
|
|
}
|
|
|
|
|
|
/**
|
|
* Création du menu contextuel du tree
|
|
* @return
|
|
*/
|
|
private void createPopupMenuTree(node nod) {
|
|
|
|
if(nod!=null) {
|
|
|
|
boolean nodeSetting = false;
|
|
boolean nodeFormatageDirectePasDeTitrePasAddMenu = false;
|
|
|
|
if(nod.chemin().contains("setting")) nodeSetting=true;
|
|
|
|
node nodStyleParent = nod.retourneParentAyantLAttribut("style:name");
|
|
if(nodStyleParent!=null) {
|
|
String nomDuStle = nodStyleParent.getAttributs().get("style:name");
|
|
Pattern p = Pattern.compile("^P[0-9]{1,}$|^T[0-9]{1,}$");
|
|
Matcher m = p.matcher(nomDuStle);
|
|
if(m.find()) {
|
|
nodeFormatageDirectePasDeTitrePasAddMenu = true;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//Menu Evaluer
|
|
JMenu mnEvaluer = new JMenu("Evaluer");
|
|
mnEvaluer.add(actEvalueTrue);
|
|
mnEvaluer.add(actEvalueFalse);
|
|
|
|
//Menu arbre
|
|
JMenu mnManageTree = new JMenu("Arbre");
|
|
mnManageTree.add(actUpNode);
|
|
mnManageTree.add(actDownNode);
|
|
mnManageTree.addSeparator();
|
|
mnManageTree.add(actExpandAll);
|
|
mnManageTree.add(actExpandNode);
|
|
mnManageTree.addSeparator();
|
|
mnManageTree.add(actCollapseAll);
|
|
mnManageTree.add(actCollapseNode);
|
|
|
|
//Menu Saut niveau >1
|
|
JMenu mnSaut = new JMenu("Saut de ligne avant");
|
|
mnSaut.setIcon( new ImageIcon(create.class.getResource("/resources/sautmini.png")));
|
|
mnSaut.add(actsauttrue);
|
|
mnSaut.add(actsautfalse);
|
|
|
|
//Menu saut niveau = 1
|
|
//Menu Saut
|
|
JMenu mnSautNiveau1 = new JMenu("Saut de ligne avant");
|
|
mnSautNiveau1.setIcon( new ImageIcon(create.class.getResource("/resources/sautmini.png")));
|
|
mnSautNiveau1.add(actsauttrue);
|
|
mnSautNiveau1.add(actsautfalse);
|
|
|
|
|
|
//Menu Titre niveau > 1
|
|
JMenu mnTitre = new JMenu("Titre");
|
|
mnTitre.setIcon( new ImageIcon(create.class.getResource("/resources/titremini.png")));
|
|
mnTitre.add(actTitrePrincipal);
|
|
mnTitre.add(actTitre1);
|
|
mnTitre.add(actTitre2);
|
|
mnTitre.add(actTitre3);
|
|
mnTitre.addSeparator();
|
|
mnTitre.add(actSupprimeTitre);
|
|
|
|
//Menu Titre niveau = 1
|
|
JMenu mnTitreNiveau1 = new JMenu("Titre");
|
|
mnTitreNiveau1.setIcon( new ImageIcon(create.class.getResource("/resources/titremini.png")));
|
|
mnTitreNiveau1.add(actTitrePrincipal);
|
|
mnTitreNiveau1.add(actTitre1);
|
|
mnTitreNiveau1.add(actTitre2);
|
|
mnTitreNiveau1.add(actTitre3);
|
|
mnTitreNiveau1.addSeparator();
|
|
mnTitreNiveau1.add(actSupprimeTitre);
|
|
|
|
//Menu ajoute un lien de menu niveau 1
|
|
JMenu mnAddMenuNiveau1= new JMenu("Lien"); //addMenu
|
|
mnAddMenuNiveau1.setIcon( new ImageIcon(create.class.getResource("/resources/addmenumini.png")));
|
|
mnAddMenuNiveau1.add(actAddMenuTrue);
|
|
mnAddMenuNiveau1.add(actAddMenuFalse);
|
|
|
|
//Menu ajoute un lien de menu niveau sup 1
|
|
JMenu mnAddMenuNiveauSup1= new JMenu("Lien"); //addMenu
|
|
mnAddMenuNiveauSup1.setIcon( new ImageIcon(create.class.getResource("/resources/addmenumini.png")));
|
|
mnAddMenuNiveauSup1.add(actAddMenuTrue);
|
|
mnAddMenuNiveauSup1.add(actAddMenuFalse);
|
|
|
|
//Menu recherche par l'index
|
|
JMenu mnRechercheIndex = new JMenu("Recherche par l'index");
|
|
mnRechercheIndex.setIcon(new ImageIcon(create.class.getResource("/resources/rechercheindexmini.png")));
|
|
mnRechercheIndex.add(actRechercheIndextrue) ;
|
|
mnRechercheIndex.addSeparator();
|
|
mnRechercheIndex.add(actRechercheIndexfalse);
|
|
|
|
//Menu recherche par le contenu Exact
|
|
JMenu mnRechercheContenu = new JMenu("Recherche par le contenu exact");
|
|
mnRechercheContenu.setIcon(new ImageIcon(create.class.getResource("/resources/recherchecontenumini.png")));
|
|
mnRechercheContenu.add(actRechercheContenutrue);
|
|
mnRechercheContenu.addSeparator();
|
|
mnRechercheContenu.add(actRechercheContenufalse);
|
|
|
|
//Menu recherche par le contenu plus proche voisin
|
|
JMenu mnRechercheContenuPlusProcheVoisin = new JMenu("Recherche par le plus proche voisin");
|
|
mnRechercheContenuPlusProcheVoisin.setIcon(new ImageIcon(create.class.getResource("/resources/recherchecontenuplusprochevoisin.png")));
|
|
mnRechercheContenuPlusProcheVoisin.add(actRechercheContenuPlusProcheVoisintrue);
|
|
mnRechercheContenuPlusProcheVoisin.addSeparator();
|
|
mnRechercheContenuPlusProcheVoisin.add(actRechercheContenuPlusProcheVoisinfalse);
|
|
|
|
|
|
|
|
//Menu analyseStyle (évaluer le style du paragraphe)
|
|
JMenu mnAnalyseStyle = new JMenu("Evaluer le style");
|
|
mnAnalyseStyle.setIcon(new ImageIcon(create.class.getResource("/resources/evaluerstylemini.png")));
|
|
mnAnalyseStyle.add(actEvaluerStyleTrue);
|
|
mnAnalyseStyle.addSeparator();
|
|
mnAnalyseStyle.add(actEvaluerStyleFalse);
|
|
|
|
//Menu Evaluer présence d'un node pour les nodes de niveau > 1
|
|
JMenu mnEvalNameNode = new JMenu("Evaluer la présence du node");
|
|
mnEvalNameNode.setIcon(new ImageIcon(create.class.getResource("/resources/evalnodemini.png")));
|
|
mnEvalNameNode.add(actEvalNameNodeOui);
|
|
mnEvalNameNode.add(actEvalNameNodeNon);
|
|
|
|
//Menue Recherche par le numéro de la page ancrer
|
|
JMenu mnRechercheParNumeroPageAncrer = new JMenu("Recherche par le numéro de la page");
|
|
mnRechercheParNumeroPageAncrer.setIcon(new ImageIcon(create.class.getResource("/resources/rechercheancragepagemini.png")));
|
|
mnRechercheParNumeroPageAncrer.add( actRechercheAnchorPageNumberTrue);
|
|
mnRechercheParNumeroPageAncrer.addSeparator();
|
|
mnRechercheParNumeroPageAncrer.add( actRechercheAnchorPageNumberFalse);
|
|
|
|
//***************************
|
|
//** Menu node niveau = 1 ***
|
|
//***************************
|
|
JMenu mnNiveau1 = new JMenu("Attributs aW, niveau 1 ");
|
|
mnNiveau1.setIcon( new ImageIcon(create.class.getResource("/resources/attributanalysewritermini.png")));
|
|
mnNiveau1.add(actCoefficient);
|
|
mnNiveau1.addSeparator();
|
|
mnNiveau1.add(mnSautNiveau1);
|
|
mnNiveau1.addSeparator();
|
|
mnNiveau1.add(mnTitreNiveau1);
|
|
mnNiveau1.addSeparator();
|
|
mnNiveau1.add(mnAddMenuNiveau1);
|
|
|
|
//***************************
|
|
//** Menu node niveau > 1 ***
|
|
//***************************
|
|
JMenu mnNiveauSup1 = new JMenu("Attributs aW, niveau " + String.valueOf(nod.getLevel() + " ") );
|
|
mnNiveauSup1.setIcon( new ImageIcon(create.class.getResource("/resources/attributanalysewritermini.png")));
|
|
JMenu mnPourFeedback = new JMenu("Pour représentation feedback");
|
|
mnPourFeedback.add(mnSaut);
|
|
if(!nodeFormatageDirectePasDeTitrePasAddMenu) {
|
|
mnPourFeedback.addSeparator();
|
|
mnPourFeedback.add(mnTitre);
|
|
mnPourFeedback.addSeparator();
|
|
mnPourFeedback.add(mnAddMenuNiveauSup1);
|
|
}
|
|
mnNiveauSup1.add(mnPourFeedback);
|
|
if(!nod.getNomElt().equals("page")) {
|
|
mnNiveauSup1.addSeparator();
|
|
mnNiveauSup1.add(mnEvalNameNode);
|
|
}
|
|
mnNiveauSup1.addSeparator();
|
|
mnNiveauSup1.add(actAllContent);
|
|
if(nod.getNomElt().equals("meta:initial-creator")) {
|
|
mnNiveauSup1.addSeparator();
|
|
mnNiveauSup1.add(actEvalInitialCreator);
|
|
}
|
|
if(nod.getNomElt().equals("dc:creator")) {
|
|
mnNiveauSup1.addSeparator();
|
|
mnNiveauSup1.add(actevalNameCreator);
|
|
}
|
|
if(ecritureSujet.listeDesNodesByRecherche(nod.getNomElt())) {
|
|
mnNiveauSup1.addSeparator();
|
|
mnNiveauSup1.add(mnRechercheIndex);
|
|
mnNiveauSup1.addSeparator();
|
|
mnNiveauSup1.add(mnRechercheContenu);
|
|
mnNiveauSup1.addSeparator();
|
|
mnNiveauSup1.add(mnRechercheContenuPlusProcheVoisin);
|
|
mnNiveauSup1.addSeparator();
|
|
mnNiveauSup1.add(mnAnalyseStyle);
|
|
}
|
|
if(ecritureSujet.listeDesRechercheAnchorPageNumber(nod.getNomElt())) {
|
|
mnNiveauSup1.addSeparator();
|
|
mnNiveauSup1.add(mnRechercheParNumeroPageAncrer);
|
|
}
|
|
|
|
|
|
//**Menu setting
|
|
JMenu mnSetting = new JMenu("Les paramètres");
|
|
mnSetting.add("CSV");
|
|
mnSetting.add("ZIP feedback");
|
|
mnSetting.add("plagiarism");
|
|
mnSetting.add("text:similarity");
|
|
mnSetting.add("translation");
|
|
|
|
|
|
//La popupMenu qui s'affiche sur le tree
|
|
JPopupMenu mnPopupTree = new JPopupMenu();
|
|
if(!nodeSetting) {
|
|
mnPopupTree.add(mnEvaluer);
|
|
}
|
|
if(nod.getLevel()==1 && !nodeSetting) {
|
|
mnPopupTree.addSeparator();
|
|
mnPopupTree.add(mnNiveau1);
|
|
}
|
|
if(nod.getLevel()>1 && !nodeSetting) {
|
|
mnPopupTree.addSeparator();
|
|
mnPopupTree.add(mnNiveauSup1);
|
|
mnPopupTree.addSeparator();
|
|
mnPopupTree.add(actAttribut);
|
|
}
|
|
if(nodeSetting) {
|
|
mnPopupTree.add(mnSetting);
|
|
}
|
|
mnPopupTree.addSeparator();
|
|
mnPopupTree.add(mnManageTree);
|
|
if(!nodeSetting) {
|
|
mnPopupTree.addSeparator();
|
|
mnPopupTree.add(actDeleteNode);
|
|
}
|
|
|
|
tree.setComponentPopupMenu(mnPopupTree);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Methode de construction de la barre de menu */
|
|
private JMenuBar createMenuBar() {
|
|
|
|
// La barre de menu à proprement parler
|
|
menuBar = new JMenuBar();
|
|
|
|
// Définition du menu déroulant "File" et de son contenu
|
|
JMenu mnuFile = new JMenu( "Fichier" );
|
|
mnuFile.setMnemonic( 'F' );
|
|
|
|
/*JMenuItem mnuNewFile =*/
|
|
mnuFile.add( actOpen );
|
|
mnuFile.add( actNewFichierAnalyse );
|
|
mnuFile.addSeparator();
|
|
mnuFile.add( actSave );
|
|
mnuFile.add( actSaveAs );
|
|
mnuFile.addSeparator();
|
|
mnuFile.add( actExit );
|
|
|
|
menuBar.add(mnuFile);
|
|
|
|
// Définition du menu déroulant "Edit" et de son contenu
|
|
JMenu mnuEdit = new JMenu( "Edition" );
|
|
mnuEdit.setMnemonic( 'E' );
|
|
|
|
mnuEdit.add( actUndo );
|
|
mnuEdit.add( actRedo );
|
|
mnuEdit.addSeparator();
|
|
mnuEdit.add( actCopy );
|
|
mnuEdit.add( actCut );
|
|
mnuEdit.add( actPaste );
|
|
|
|
menuBar.add(mnuEdit);
|
|
|
|
// Définition du menu Node
|
|
JMenu mnNode = new JMenu("Modifier");
|
|
mnNode.add( actNodeFichier );
|
|
mnNode.addSeparator();
|
|
menuBar.add(mnNode);
|
|
|
|
//Menu arbre
|
|
JMenu mnManageTree = new JMenu("Arbre");
|
|
mnManageTree.add(actUpNode);
|
|
mnManageTree.add(actDownNode);
|
|
mnManageTree.addSeparator();
|
|
mnManageTree.add(actExpandAll);
|
|
mnManageTree.add(actExpandNode);
|
|
mnManageTree.addSeparator();
|
|
mnManageTree.add(actCollapseAll);
|
|
mnManageTree.add(actCollapseNode);
|
|
mnNode.add(mnManageTree);
|
|
mnNode.addSeparator();
|
|
|
|
//Définition Evaluer
|
|
JMenu mnEvaluer = new JMenu("Evaluer");
|
|
mnEvaluer.add(actEvalueTrue);
|
|
mnEvaluer.add(actEvalueFalse);
|
|
mnNode.add(mnEvaluer);
|
|
|
|
|
|
|
|
// Définition du menu déroulant "Création évaluation" et de son contenu
|
|
JMenu mnuExercice = new JMenu( "Création évaluation" );
|
|
mnuExercice.setMnemonic( 'N' );
|
|
mnuExercice.add(actEvaluer);
|
|
|
|
menuBar.add(mnuExercice);
|
|
|
|
// Définition du menu déroulant "Help" et de son contenu
|
|
JMenu mnuHelp = new JMenu( "Aide" );
|
|
mnuHelp.setMnemonic( 'H' );
|
|
|
|
mnuHelp.add( actAPropos);
|
|
mnuHelp.add( actDocumentation);
|
|
|
|
menuBar.add( mnuHelp );
|
|
|
|
return menuBar;
|
|
}
|
|
|
|
/* Methode de construction de la barre d'outils */
|
|
private void createToolBar() {
|
|
toolBar_1 = new JToolBar();
|
|
|
|
JButton buttonLoadFile = toolBar_1.add( actOpen );
|
|
buttonLoadFile.setIcon(new ImageIcon(create.class.getResource("/resources/fichierAnalyse.png")));
|
|
buttonLoadFile.setHideActionText(true);
|
|
toolBar_1.add(buttonLoadFile);
|
|
|
|
JButton btnNewFichierAnalyse = toolBar_1.add( actNewFichierAnalyse );
|
|
btnNewFichierAnalyse.setIcon(new ImageIcon(create.class.getResource("/resources/fichierODF.png")));
|
|
btnNewFichierAnalyse.setHideActionText(true);
|
|
toolBar_1.add(btnNewFichierAnalyse);
|
|
|
|
toolBar_1.addSeparator();
|
|
|
|
buttonEvaluate = toolBar_1.add( actEvaluer );
|
|
buttonEvaluate.addActionListener(new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
}
|
|
});
|
|
buttonEvaluate.setIcon(new ImageIcon(create.class.getResource("/resources/evaluate.png")));
|
|
|
|
toolBar_1.addSeparator();
|
|
|
|
JButton btnAfficheInformationFichierAnalyse = toolBar_1.add( actAfficheInformationFichierAnalyse );
|
|
btnAfficheInformationFichierAnalyse.setIcon(new ImageIcon(create.class.getResource("/resources/fichierAnalyseInfo.png")));
|
|
btnAfficheInformationFichierAnalyse.setHideActionText(true);
|
|
toolBar_1.add(btnAfficheInformationFichierAnalyse);
|
|
|
|
JButton btnNodeFichier = toolBar_1.add( actNodeFichier );
|
|
btnNodeFichier.setIcon(new ImageIcon(create.class.getResource("/resources/nodeFichier.png")));
|
|
btnNodeFichier.setHideActionText(true);
|
|
toolBar_1.add(btnNodeFichier);
|
|
|
|
JButton btnSetting = toolBar_1.add( actSetting);
|
|
btnSetting.setIcon(new ImageIcon(create.class.getResource("/resources/setting.png")));
|
|
toolBar_1.add(btnSetting);
|
|
|
|
|
|
toolBar_1.addSeparator();
|
|
|
|
JButton btnEvaluerTrue = toolBar_1.add( actEvalueTrue );
|
|
btnEvaluerTrue.setIcon(new ImageIcon(create.class.getResource("/resources/evaluertrue.png")));
|
|
btnEvaluerTrue.setHideActionText(true);
|
|
toolBar_1.add(btnEvaluerTrue);
|
|
|
|
JButton btnEvaluerFalse = toolBar_1.add( actEvalueFalse );
|
|
btnEvaluerFalse.setIcon(new ImageIcon(create.class.getResource("/resources/evaluerfalse.png")));
|
|
btnEvaluerFalse.setHideActionText(true);
|
|
toolBar_1.add(btnEvaluerFalse);
|
|
|
|
JButton btnEvaluerTouteLaBrancheEtLesEnfantTrue = toolBar_1.add( actEvaluerTousEnfantsTrue );
|
|
btnEvaluerTouteLaBrancheEtLesEnfantTrue.setIcon(new ImageIcon(create.class.getResource("/resources/evaluertouslesenfants.png")));
|
|
btnEvaluerTouteLaBrancheEtLesEnfantTrue.setHideActionText(true);
|
|
toolBar_1.add(btnEvaluerTouteLaBrancheEtLesEnfantTrue);
|
|
|
|
JButton btnEvaluerTouteLaBrancheEtLesEnfantFalse = toolBar_1.add( actEvaluerTousEnfantsFalse );
|
|
btnEvaluerTouteLaBrancheEtLesEnfantFalse.setIcon(new ImageIcon(create.class.getResource("/resources/evaluertouslesenfantsfaux.png")));
|
|
btnEvaluerTouteLaBrancheEtLesEnfantTrue.setHideActionText(true);
|
|
toolBar_1.add(btnEvaluerTouteLaBrancheEtLesEnfantFalse);
|
|
|
|
toolBar_1.addSeparator();
|
|
|
|
|
|
JButton btnAttribut = new JButton(actAttribut);
|
|
btnAttribut.setText("");
|
|
btnAttribut.setIcon(new ImageIcon(create.class.getResource("/resources/attribut.png")));
|
|
toolBar_1.add(btnAttribut);
|
|
|
|
toolBar_1.addSeparator();
|
|
|
|
JButton btnTotalPoint = new JButton(actTotalPoint);
|
|
btnTotalPoint.setToolTipText("");
|
|
btnTotalPoint.setText("");
|
|
btnTotalPoint.setIcon(new ImageIcon(create.class.getResource("/resources/totalpoint.png")));
|
|
toolBar_1.add(btnTotalPoint);
|
|
|
|
JButton btnTotalPointNode = toolBar_1.add( actTotalPointNode );
|
|
btnTotalPointNode.setIcon(new ImageIcon(create.class.getResource("/resources/totalpointnode.png")));
|
|
btnTotalPointNode.setHideActionText(true);
|
|
toolBar_1.add(btnTotalPointNode);
|
|
|
|
toolBar_1.addSeparator();
|
|
|
|
|
|
tglbtnTousLesNodes = new JToggleButton("");
|
|
tglbtnTousLesNodes.setAction(actTousLesNodesEvaluer);
|
|
tglbtnTousLesNodes.setIcon(new ImageIcon(create.class.getResource("/resources/lesnodesevaluer.png")));
|
|
toolBar_1.add(tglbtnTousLesNodes);
|
|
|
|
toolBar_1.addSeparator();
|
|
|
|
JButton btnAbout = toolBar_1.add( actAbout );
|
|
btnAbout.setIcon(new ImageIcon(create.class.getResource("/resources/apropos.png")));
|
|
btnAbout.setHideActionText( true );
|
|
toolBar_1.add(btnAbout);
|
|
|
|
|
|
JButton btnNewButton = toolBar_1.add(actTutoriels);
|
|
btnNewButton.setIcon(new ImageIcon(create.class.getResource("/resources/tutoriel.png")));
|
|
btnNewButton.setHideActionText(true);
|
|
toolBar_1.add(btnNewButton);
|
|
|
|
toolBar_1.addSeparator();
|
|
|
|
JButton button_2 = toolBar_1.add( actExit );
|
|
button_2.setHideActionText( true );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Ouvre et affiche le fichier d'analyse
|
|
*/
|
|
private AbstractAction actOpen = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Ouvrir un fichier d'analyse" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/fichierAnalysemini.png")) );
|
|
putValue( Action.MNEMONIC_KEY, KeyEvent.VK_O );
|
|
putValue( Action.SHORT_DESCRIPTION, "Ouvrir un nouveau fichier d'analyse (CTRL+O)" );
|
|
putValue( Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_O, InputEvent.CTRL_DOWN_MASK) );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
new filechooserXML();
|
|
if(commandes.fichierAnalyseValide) {
|
|
constructionTree();
|
|
textNodeSelect.afficheChargementFichierAnalyse();
|
|
}else {
|
|
constructionTree();
|
|
textNodeSelect.setContentType("text/plain");
|
|
textNodeSelect.setText(commandes.message.toString());
|
|
}
|
|
System.out.println( "Open" );
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Affiche le tree contenant tous les nodes
|
|
*/
|
|
private AbstractAction actTousLesNodesEvaluer = new AbstractAction() {
|
|
private static final long serialVersionUID = 1L;
|
|
{
|
|
putValue( Action.NAME, "" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/touslesnodesmini.png")) );
|
|
putValue( Action.SHORT_DESCRIPTION, "Affiche tous les nodes" );
|
|
}
|
|
@Override
|
|
public void actionPerformed(ActionEvent e) {
|
|
if(tglbtnTousLesNodes.isSelected()) {
|
|
try {
|
|
commandes.sujetSauvegarde = commandes.sujet.clone();
|
|
commandes.sujet.supprimeTousLesNodesEvaluerFalseOuNull();
|
|
commandes.fichierAnalyseValide=false;
|
|
textNodeSelect.setContentType("text/html");
|
|
textNodeSelect.setText("<hr><h1>Affiche uniquement les nodes évalués par l'application.</h1><hr>"
|
|
+ "<br><h2><u>Le chemin vers chaque node évalué est constitué de node évalué.</u><br>"
|
|
+ "Si vous enregistrez maintenant, vous enregistrez le fichier d'analyse avec <u>uniquement</u> les nodes évalués.</h2>");
|
|
buttonEvaluate.setEnabled(false);
|
|
constructionTree();
|
|
} catch (CloneNotSupportedException e1) {
|
|
e1.printStackTrace();
|
|
}
|
|
}else {
|
|
try {
|
|
commandes.sujet = commandes.sujetSauvegarde.clone();
|
|
buttonEvaluate.setEnabled(true);
|
|
} catch (CloneNotSupportedException e1) {
|
|
e1.printStackTrace();
|
|
}
|
|
textNodeSelect.setContentType("text/html");
|
|
textNodeSelect.setText("<hr><h1>Affiche tous les nodes évalués ou pas.</h1><hr>");
|
|
commandes.fichierAnalyseValide=true;
|
|
constructionTree();
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
*
|
|
*/
|
|
private AbstractAction actNodeFichier = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Modifier les paramètres de l'évaluation" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/nodeFichiermini.png")) );
|
|
putValue( Action.LARGE_ICON_KEY, new ImageIcon(create.class.getResource("/resources/nodeFichier.png")) );
|
|
putValue( Action.SHORT_DESCRIPTION, "Modifier les paramètres de l'évaluation" );
|
|
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
if(commandes.sujet.getNomElt().equals("fichier")) {
|
|
new proprieteFichierAnalyse(textNodeSelect);
|
|
|
|
}
|
|
System.out.println( "ouvre la fenêtre propriété du fichier d'analyse" );
|
|
}
|
|
};
|
|
|
|
/**
|
|
*
|
|
*/
|
|
private AbstractAction actSetting = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Settings" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/settingmini.png")) );
|
|
putValue( Action.LARGE_ICON_KEY, new ImageIcon(create.class.getResource("/resources/setting.png")) );
|
|
putValue( Action.SHORT_DESCRIPTION, "Modifier les paramètres" );
|
|
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
if(commandes.sujet.getNomElt().equals("fichier")) {
|
|
new setting();
|
|
|
|
}
|
|
System.out.println( "ouvre la fenêtre setting" );
|
|
}
|
|
};
|
|
|
|
/**
|
|
*
|
|
*/
|
|
private AbstractAction actAttribut = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Evaluer les attributs Writer" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/attributmini.png")) );
|
|
putValue( Action.LARGE_ICON_KEY, new ImageIcon(create.class.getResource("/resources/attributmini.png")) );
|
|
putValue( Action.SHORT_DESCRIPTION, "Evaluer les attributs du traitement de texte Writer" );
|
|
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
node nod = (node) selectNode.getUserObject();
|
|
|
|
int nbrAttribut = nod.getAttributs().size();
|
|
System.out.println("Nbr attribut brut = " + nbrAttribut);
|
|
|
|
Enumeration<String> k = nod.getAttributs().keys();
|
|
while(k.hasMoreElements()) {
|
|
|
|
String key = k.nextElement();
|
|
if(listeAttributsAnalyseWriter.isAttributAnalyseWriter(key)) {
|
|
nbrAttribut--;
|
|
}
|
|
}
|
|
|
|
System.out.println("Nbr attribut writer = " + nbrAttribut);
|
|
|
|
if(nbrAttribut>0) {
|
|
if(nod.getLevel()>1 && !nod.chemin().contains("setting")) {
|
|
new attributs(nod,textNodeSelect);
|
|
}else {
|
|
JOptionPane.showMessageDialog(null, "Vous ne pouvez pas modifier les attributs de ce node.");
|
|
}
|
|
}else {
|
|
JOptionPane.showMessageDialog(null, "Ce node ne contient pas d'attribut Writer.");
|
|
}
|
|
System.out.println( "ouvre la fenêtre attributs" );
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Affiche la fenêtre d'information sur analyseWriter
|
|
*/
|
|
private AbstractAction actAbout = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Informations" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/aproposmini.png")) );
|
|
putValue( Action.MNEMONIC_KEY, KeyEvent.VK_I );
|
|
putValue( Action.SHORT_DESCRIPTION, "Informations (CTRL+I)" );
|
|
putValue( Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_I, InputEvent.CTRL_DOWN_MASK) );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
new about();
|
|
System.out.println( "About" );
|
|
}
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* Enregistrer
|
|
*/
|
|
private AbstractAction actSave = new AbstractAction() {
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Enregister" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon( getClass().getResource("/save.png")) );
|
|
putValue( Action.MNEMONIC_KEY, KeyEvent.VK_S );
|
|
putValue( Action.SHORT_DESCRIPTION, "Enregistrer (CTRL+S)" );
|
|
putValue( Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_S, KeyEvent.CTRL_DOWN_MASK ) );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
|
|
Pattern p = Pattern.compile("[.xml]\\b");
|
|
Matcher m = p.matcher(commandes.nameSujet);
|
|
|
|
String message="";
|
|
|
|
if(m.find()) {
|
|
message="\"Voulez-vous enregistrer le fichier \"" + commandes.nameSujet + "\"\n"
|
|
+ "Dans le dossier " + commandes.PathFilenameAnalysis;
|
|
}else {
|
|
message="\"Voulez-vous enregistrer le fichier \"" + commandes.nameSujet + ".xml\"\n"
|
|
+ "Dans le dossier " + commandes.PathFilenameAnalysis;
|
|
commandes.nameSujet = commandes.nameSujet + ".xml";
|
|
}
|
|
|
|
int input = JOptionPane.showConfirmDialog(null, message);
|
|
|
|
if(input==0) {
|
|
try {
|
|
verificationFichierAnalyse.MiseAJourHashNomFichierAnalyse(commandes.nameSujet);
|
|
Run.ecritureNodeEnXML(commandes.sujet, commandes.nameSujet ,commandes.PathFilenameAnalysis,"sujet");
|
|
|
|
if(m.find()) {
|
|
textNodeSelect.setText("Le fichier \"" + commandes.nameSujet + " a été réenregistré.\n\n"
|
|
+ "Il se trouve dans le dossier " + commandes.PathFilenameAnalysis);
|
|
}else {
|
|
textNodeSelect.setText("Le fichier \"" + commandes.nameSujet + ".xml\" a été réenregistré.\n\n"
|
|
+ "Il se trouve dans le dossier " + commandes.PathFilenameAnalysis);
|
|
}
|
|
|
|
System.out.println( input + "Save" );
|
|
} catch (IOException | CloneNotSupportedException e1) {
|
|
e1.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Enregistrer sous ...
|
|
*/
|
|
private AbstractAction actSaveAs = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Enregistrer sous..." );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(getClass().getResource("/save_as.png") ));
|
|
putValue( Action.MNEMONIC_KEY, KeyEvent.VK_A );
|
|
putValue( Action.SHORT_DESCRIPTION, "Enregistrer sous..." );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
|
|
JFileChooser fileChooser = new JFileChooser();
|
|
fileChooser.setDialogTitle("Enregistrer sous...");
|
|
File file = null;
|
|
|
|
if(!commandes.nameSujet.isEmpty()) {
|
|
file = new File(commandes.PathFilenameAnalysis ); //+ "\\" + utils.filename + ".xml"
|
|
}
|
|
|
|
|
|
|
|
fileChooser.setCurrentDirectory(file);
|
|
|
|
int userSelection = fileChooser.showSaveDialog(null);
|
|
|
|
if (userSelection == JFileChooser.APPROVE_OPTION) {
|
|
File fileToSave = fileChooser.getSelectedFile();
|
|
try {
|
|
|
|
verificationFichierAnalyse.MiseAJourHashNomFichierAnalyse(fileToSave.getName());
|
|
|
|
|
|
Run.ecritureNodeEnXML(commandes.sujet, fileToSave.getName(), fileToSave.getPath().substring(0,fileToSave.getPath().lastIndexOf("\\")),"sujet" );
|
|
|
|
commandes.nameSujet = fileToSave.getName();
|
|
commandes.PathFilenameAnalysis = fileToSave.getPath().substring(0,fileToSave.getPath().lastIndexOf("\\"));
|
|
|
|
Pattern p = Pattern.compile("[.xml]\\b");
|
|
Matcher m = p.matcher(commandes.nameSujet);
|
|
|
|
if(m.find()) {
|
|
file = new File(commandes.PathFilenameAnalysis + "\\" + commandes.nameSujet);
|
|
textNodeSelect.setText("Le fichier \"" + commandes.nameSujet + " a été renregistré.\n\nIl se trouve dans le dossier " + commandes.PathFilenameAnalysis);
|
|
}else {
|
|
file = new File(commandes.PathFilenameAnalysis + "\\" + commandes.nameSujet + ".xml");
|
|
textNodeSelect.setText("Le fichier \"" + commandes.nameSujet + ".xml\" a été renregistré.\n\nIl se trouve dans le dossier " + commandes.PathFilenameAnalysis);
|
|
}
|
|
|
|
|
|
} catch (IOException e1) {
|
|
e1.printStackTrace();
|
|
} catch (CloneNotSupportedException e1) {
|
|
e1.printStackTrace();
|
|
}
|
|
System.out.println("Save as file: " + fileToSave.getAbsolutePath());
|
|
}
|
|
System.out.println( "Save as" );
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Quitter l'application
|
|
*/
|
|
private AbstractAction actExit = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Quitter" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/exitmini.png")) );
|
|
putValue( Action.LARGE_ICON_KEY, new ImageIcon(create.class.getResource("/resources/exit.png")) );
|
|
putValue( Action.MNEMONIC_KEY, KeyEvent.VK_Q );
|
|
putValue( Action.SHORT_DESCRIPTION, "Quitter (CRTL+Q)" );
|
|
putValue( Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_Q, KeyEvent.CTRL_DOWN_MASK ) );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
|
|
int a = JOptionPane.showConfirmDialog(null,"Voulez-vous quitter l'application?", "Sélectionner un choix", JOptionPane.YES_NO_OPTION);
|
|
|
|
if(a == JOptionPane.YES_NO_OPTION) {
|
|
System.out.println( "Le choix : " + a);
|
|
System.out.println( "Exit" + e.getSource().toString());
|
|
create.this.dispose();
|
|
}
|
|
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
*
|
|
*/
|
|
private AbstractAction actUndo = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Annuler" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon( getClass().getResource("/undo.png") ) );
|
|
putValue( Action.MNEMONIC_KEY, KeyEvent.VK_U );
|
|
putValue( Action.SHORT_DESCRIPTION, "Annuler (CTRL+Z)" );
|
|
putValue( Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_Z, KeyEvent.CTRL_DOWN_MASK ) );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
System.out.println( "Undo" );
|
|
}
|
|
};
|
|
|
|
/**
|
|
*
|
|
*/
|
|
private AbstractAction actRedo = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Refaire" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon( getClass().getResource("/redo.png") ) );
|
|
putValue( Action.MNEMONIC_KEY, KeyEvent.VK_R );
|
|
putValue( Action.SHORT_DESCRIPTION, "Refaire (CTRL+U)" );
|
|
putValue( Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_U, KeyEvent.CTRL_DOWN_MASK ) );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
System.out.println( "Redo" );
|
|
}
|
|
};
|
|
|
|
/**
|
|
*
|
|
*/
|
|
private AbstractAction actCopy = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Copier" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon( getClass().getResource("/copy.png") ) );
|
|
putValue( Action.MNEMONIC_KEY, KeyEvent.VK_C );
|
|
putValue( Action.SHORT_DESCRIPTION, "Copier (CTRL+C)" );
|
|
putValue( Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_C, KeyEvent.CTRL_DOWN_MASK ) );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
System.out.println( "Copy" );
|
|
}
|
|
};
|
|
|
|
/**
|
|
*
|
|
*/
|
|
private AbstractAction actAfficheInformationFichierAnalyse = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Affiche informations" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Affiche les informations du fichier d'analyse." );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
textNodeSelect.afficheChargementFichierAnalyse();
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
*
|
|
*/
|
|
private AbstractAction actCut = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Couper" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon( getClass().getResource("/cut.png") ) );
|
|
putValue( Action.MNEMONIC_KEY, KeyEvent.VK_T );
|
|
putValue( Action.SHORT_DESCRIPTION, "Couper (CTRL+X)" );
|
|
putValue( Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_X, KeyEvent.CTRL_DOWN_MASK ) );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
System.out.println( "Cut" );
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Ajoute ou modifie le poid d'un node
|
|
*/
|
|
private AbstractAction actCoefficient = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Coefficient (poids)" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/poidsmini.png")) );
|
|
putValue( Action.SHORT_DESCRIPTION, "Coefficient (poids)" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
double poids = 1.00;
|
|
if(nod.getAttributs().get("poids")!=null) {
|
|
try {
|
|
poids = Double.valueOf(nod.getAttributs().get("poids"));
|
|
} catch (Exception e2) {
|
|
System.out.println(e2.toString());
|
|
}
|
|
}
|
|
|
|
String a = JOptionPane.showInputDialog(null,"Quel est le coefficient de cette partie de l'évaluation?",poids);
|
|
|
|
if(!a.isEmpty()) {
|
|
try {
|
|
poids = Double.valueOf(a);
|
|
if(poids<=0) {
|
|
nod.poids(Double.valueOf(1));
|
|
textNodeSelect.setText(balisestyles());
|
|
textNodeSelect.setText("<h2>Erreur la valeur doit être un nombre entier POSITIF supérieur à zéro.<br>Cependant,la valeur a été modifiée.<br>poids=1.</h2>");
|
|
}else {
|
|
nod.poids(Double.valueOf(poids));
|
|
textNodeSelect.refreshAffichage(nod);
|
|
}
|
|
} catch (Exception e2) {
|
|
textNodeSelect.setText(balisestyles());
|
|
textNodeSelect.setText("<h2>Erreur la valeur doit être un nombre entier.<br>La valeur n'a pas été modifiée.</h2>");
|
|
}
|
|
}
|
|
|
|
}
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* Evalue la présence de ce node
|
|
*/
|
|
private AbstractAction actEvalNameNodeOui = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Oui, combien de point?" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Evaluer la présence de ce node" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
int point = 0;
|
|
if(nod.getAttributs().get("evalNameNode")!=null) {
|
|
point = Integer.valueOf(nod.getAttributs().get("evalNameNode"));
|
|
}
|
|
|
|
String a = JOptionPane.showInputDialog(null,"Quel est le nombre de point?",point);
|
|
|
|
if(!a.isEmpty()) {
|
|
try {
|
|
point = Integer.valueOf(a);
|
|
if(point<=0) {
|
|
nod.getAttributs().put("evalNameNode", String.valueOf(0));
|
|
textNodeSelect.setText(balisestyles());
|
|
textNodeSelect.setText("<h2>Erreur la valeur doit être un nombre entier POSITIF supérieur à zéro.<br>Cependant,la valeur a été modifiée.<br>evalNameNode=0.</h2>");
|
|
}else {
|
|
nod.getAttributs().put("evalNameNode", String.valueOf(point));
|
|
}
|
|
} catch (Exception e2) {
|
|
textNodeSelect.setText(balisestyles());
|
|
textNodeSelect.setText("<h2>Erreur la valeur doit être un nombre entier.<br>L'attribut n'a pas été modifiée.</h2>");
|
|
}
|
|
}
|
|
textNodeSelect.refreshAffichage(nod);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Evalue la présence du node meta:initial-creator
|
|
*/
|
|
private AbstractAction actEvalInitialCreator = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Evaluer la présence du premier auteur (créateur)" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Evaluer la présence du premier auteur (créateur)" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/auteurcreateurmini.png")) );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
int point = 0;
|
|
if(nod.getAttributs().get("evalNameInitialCreator")!=null) {
|
|
point = Integer.valueOf(nod.getAttributs().get("evalNameInitialCreator"));
|
|
}
|
|
|
|
String a = JOptionPane.showInputDialog(null,"Quel est le nombre de point?",point);
|
|
|
|
if(!a.isEmpty()) {
|
|
try {
|
|
point = Integer.valueOf(a);
|
|
if(point<=0) {
|
|
nod.getAttributs().put("evalNameInitialCreator", String.valueOf(0));
|
|
textNodeSelect.setText(balisestyles());
|
|
textNodeSelect.setText("<h2>Erreur la valeur doit être un nombre entier POSITIF supérieur à zéro.<br>Cependant,la valeur a été modifiée.<br>evalNameInitialCreator=0.</h2>");
|
|
}else {
|
|
nod.getAttributs().put("evalNameInitialCreator", String.valueOf(point));
|
|
}
|
|
} catch (Exception e2) {
|
|
textNodeSelect.setText(balisestyles());
|
|
textNodeSelect.setText("<h2>Erreur la valeur doit être un nombre entier.<br>L'attribut n'a pas été modifiée.</h2>");
|
|
}
|
|
}
|
|
textNodeSelect.refreshAffichage(nod);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Evalue la présence du node dc:creator
|
|
*/
|
|
private AbstractAction actevalNameCreator = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Evaluer la présence du dernier éditeur" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Evaluer la présence du dernier éditeur" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/auteurediteurmini.png")) );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
int point = 0;
|
|
if(nod.getAttributs().get("evalNameCreator")!=null) {
|
|
point = Integer.valueOf(nod.getAttributs().get("evalNameCreator"));
|
|
}
|
|
|
|
String a = JOptionPane.showInputDialog(null,"Quel est le nombre de point?",point);
|
|
|
|
if(!a.isEmpty()) {
|
|
try {
|
|
point = Integer.valueOf(a);
|
|
if(point<=0) {
|
|
nod.getAttributs().put("evalNameCreator", String.valueOf(0));
|
|
textNodeSelect.setText(balisestyles());
|
|
textNodeSelect.setText("<h2>Erreur la valeur doit être un nombre entier POSITIF supérieur à zéro.<br>Cependant,la valeur a été modifiée.<br>evalNameCreator=0.</h2>");
|
|
}else {
|
|
nod.getAttributs().put("evalNameCreator", String.valueOf(point));
|
|
}
|
|
} catch (Exception e2) {
|
|
textNodeSelect.setText(balisestyles());
|
|
textNodeSelect.setText("<h2>Erreur la valeur doit être un nombre entier.<br>L'attribut n'a pas été modifiée.</h2>");
|
|
}
|
|
}
|
|
textNodeSelect.refreshAffichage(nod);
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Evalue la présence de ce node
|
|
*/
|
|
private AbstractAction actAllContent = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Evaluer le contenu du node" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Evaluer le contenu du node" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/allcontentmini.png")) );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
new allContent(nod,textNodeSelect);
|
|
|
|
}
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* Evalue la présence de ce node
|
|
*/
|
|
private AbstractAction actEvalNameNodeNon = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Supprime l'évaluation de la présence du node" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Supprime l'évaluation de la présence du node" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
nod.supprimeAttribut("evalNameNode");
|
|
textNodeSelect.refreshAffichage(nod);
|
|
// refeshNodeSelected();
|
|
|
|
}
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* Ajoute ou modifie le titre principal
|
|
*/
|
|
private AbstractAction actTitrePrincipal = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Titre principal" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Titre principal" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
String titre = "";
|
|
if(nod.getAttributs().get("titre")!=null) {
|
|
titre = nod.getAttributs().get("titre");
|
|
}
|
|
|
|
String a = JOptionPane.showInputDialog(null,"Quel est le titre?",titre);
|
|
nod.titre(a);
|
|
textNodeSelect.refreshAffichage(nod);
|
|
// refeshNodeSelected();
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Ajoute ou modifie le titre principal
|
|
*/
|
|
private AbstractAction actSupprimeTitre = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Supprimer le titre" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Supprime le titre" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
if(nod.getAttributs().get("titre")!=null) {
|
|
nod.supprimeAttribut("titre");
|
|
}
|
|
if(nod.getAttributs().get("titre1")!=null) {
|
|
nod.supprimeAttribut("titre1");
|
|
}
|
|
if(nod.getAttributs().get("titre2")!=null) {
|
|
nod.supprimeAttribut("titre2");
|
|
}
|
|
if(nod.getAttributs().get("titre3")!=null) {
|
|
nod.supprimeAttribut("titre3");
|
|
}
|
|
textNodeSelect.refreshAffichage(nod);
|
|
// refeshNodeSelected();
|
|
}
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* Ajoute ou modifie le titre 1
|
|
*/
|
|
private AbstractAction actTitre1 = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Titre 1" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Titre 1" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
String titre = "";
|
|
if(nod.getAttributs().get("titre1")!=null) {
|
|
titre = nod.getAttributs().get("titre1");
|
|
}
|
|
|
|
String a = JOptionPane.showInputDialog(null,"Quel est le titre?",titre);
|
|
nod.titre1(a);
|
|
textNodeSelect.refreshAffichage(nod);
|
|
// refeshNodeSelected();
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Ajoute ou modifie le titre 2
|
|
*/
|
|
private AbstractAction actTitre2 = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Titre 2" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Titre 2" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
String titre = "";
|
|
if(nod.getAttributs().get("titre2")!=null) {
|
|
titre = nod.getAttributs().get("titre2");
|
|
}
|
|
|
|
String a = JOptionPane.showInputDialog(null,"Quel est le titre?",titre);
|
|
nod.titre2(a);
|
|
textNodeSelect.refreshAffichage(nod);
|
|
// refeshNodeSelected();
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Ajoute ou modifie le titre 3
|
|
*/
|
|
private AbstractAction actTitre3 = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Titre 3" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Titre 3" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
String titre = "";
|
|
if(nod.getAttributs().get("titre3")!=null) {
|
|
titre = nod.getAttributs().get("titre3");
|
|
}
|
|
|
|
String a = JOptionPane.showInputDialog(null,"Quel est le titre?",titre);
|
|
nod.titre3(a);
|
|
textNodeSelect.refreshAffichage(nod);
|
|
// refeshNodeSelected();
|
|
}
|
|
};
|
|
|
|
|
|
private AbstractAction actTotalPoint = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Nombre de point" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Nombre de points dans le node" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/totalpointmini.png")) );
|
|
putValue( Action.LARGE_ICON_KEY, new ImageIcon(create.class.getResource("/resources/totalpoint.png")) );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
System.out.println("Calcul le nombre de point dans le sujet");
|
|
textNodeSelect.AfficheTotalPoint(commandes.sujet,calculNombreDepoint(commandes.sujet,0));
|
|
}
|
|
};
|
|
|
|
|
|
private AbstractAction actTotalPointNode = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Nombre de point" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Nombre de points dans le node" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/totalpointnodemini.png")) );
|
|
putValue( Action.LARGE_ICON_KEY, new ImageIcon(create.class.getResource("/resources/totalpointnode.png")) );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
System.out.println("Calcul le nombre de point dans le node");
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
textNodeSelect.AfficheTotalPoint(nod,calculNombreDepoint(nod,0));
|
|
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Recherche par l'index true
|
|
*/
|
|
private AbstractAction actRechercheIndextrue = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Recherche par l'index du node : true" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Recherche par index le node dans le fichier de l'étudiant." );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
nod.getAttributs().put("recherche_index", "true");
|
|
textNodeSelect.refreshAffichage(nod);
|
|
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Evalue le style:name true
|
|
*/
|
|
private AbstractAction actEvaluerStyleTrue = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Evaluer le style." );
|
|
putValue( Action.SHORT_DESCRIPTION, "Evaluer le style:name de ce node dans le fichier de l'étudiant" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
nod.getAttributs().put("analyseStyle", "true");
|
|
|
|
//***************************************************************************************************************
|
|
//** Place l'attribut EvaluerATraversAnalyseStyle=true au style qui doit être évaluer à travers d'analyseStyle **
|
|
//** S'il y a des attributs évaluer avec ‽ alors change par ‼ **
|
|
//***************************************************************************************************************
|
|
node nodStyle = commandes.sujet.retourneFirstNodeByNameAndAttributValueExactStrict("style:style", "style:name", nod.getAttributs().get("text:style-name"));
|
|
if(nodStyle!=null) {
|
|
nodStyle.getAttributs().put("EvaluerATraversAnalyseStyle", "true");
|
|
nodStyle.evaluerTrue();
|
|
nodStyle.changeLesCodesEvaluateursVersCodeATraversAnalyseStyle();
|
|
}
|
|
|
|
textNodeSelect.refreshAffichage(nod);
|
|
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Evalue le style:name true
|
|
*/
|
|
private AbstractAction actEvaluerStyleFalse = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "N'évaluer pas le style." );
|
|
putValue( Action.SHORT_DESCRIPTION, "N'évaluer pas le style:name de ce node dans le fichier de l'étudiant" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
nod.getAttributs().put("analyseStyle", "false");
|
|
|
|
//***************************************************************************************************************
|
|
//** Place l'attribut EvaluerATraversAnalyseStyle=false au style qui doit être évaluer à travers d'analyseStyle **
|
|
//** S'il y a des attribut évaluer avec ‼ alors change par ‽ **
|
|
//***************************************************************************************************************
|
|
node nodStyle = commandes.sujet.retourneFirstNodeByNameAndAttributValueExactStrict("style:style", "style:name", nod.getAttributs().get("text:style-name"));
|
|
if(nodStyle!=null) {
|
|
nodStyle.getAttributs().put("EvaluerATraversAnalyseStyle", "false");
|
|
nodStyle.evaluerAllChildFalse();
|
|
if(!listeNodeFormatageDirectDeWriter.isFormatageDirect(nodStyle)) {
|
|
nodStyle.changeLesCodesEvaluateursVersCodeEvaluateurDirect();
|
|
}
|
|
}
|
|
|
|
textNodeSelect.refreshAffichage(nod);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Recherche le node par l'index false
|
|
*/
|
|
private AbstractAction actRechercheIndexfalse = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Ne recherche par l'index du node : false" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Ne recherche pas par l'index le node dans le fichier de l'étudiant." );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
nod.getAttributs().put("recherche_index", "false");
|
|
textNodeSelect.refreshAffichage(nod);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Recherche le node par le contenu true
|
|
*/
|
|
private AbstractAction actRechercheContenutrue= new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Recherche par le contenu du node : true" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Recherche par le contenu le node dans le fichier de l'étudiant." );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
nod.getAttributs().put("recherche_contenu_exact", "true");
|
|
textNodeSelect.refreshAffichage(nod);
|
|
}
|
|
};
|
|
/**
|
|
* Recherche le node par le contenu true
|
|
*/
|
|
private AbstractAction actRechercheContenuPlusProcheVoisintrue= new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "true" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Recherche par le contenu du plus proche voisin." );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
nod.getAttributs().put("recherche_contenu_plus_proche_voisin", "true");
|
|
textNodeSelect.refreshAffichage(nod);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Recherche le node par le contenu false
|
|
*/
|
|
private AbstractAction actRechercheContenufalse= new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "false" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Ne recherche pas par le contenu le node dans le fichier de l'étudiant." );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
nod.getAttributs().put("recherche_contenu_exact", "false");
|
|
textNodeSelect.refreshAffichage(nod);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Recherche le node par le contenu true
|
|
*/
|
|
private AbstractAction actRechercheContenuPlusProcheVoisinfalse= new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Plus proche voisin : false" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Ne recherche pas par le contenu du plus proche voisin." );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
nod.getAttributs().put("recherche_contenu_plus_proche_voisin", "false");
|
|
textNodeSelect.refreshAffichage(nod);
|
|
}
|
|
};
|
|
/**
|
|
* Recherche par le numéro de la page true
|
|
*/
|
|
private AbstractAction actRechercheAnchorPageNumberTrue = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "true" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Recherche l'image par le numéro de la page dans le node dans le fichier de l'étudiant." );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
nod.getAttributs().put("recherche_anchor-page-number", "true");
|
|
textNodeSelect.refreshAffichage(nod);
|
|
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Recherche par le numéro de la page true
|
|
*/
|
|
private AbstractAction actRechercheAnchorPageNumberFalse = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "false" );
|
|
putValue( Action.SHORT_DESCRIPTION, "Ne recherche pas l'image par le numéro de la page." );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
nod.getAttributs().put("recherche_anchor-page-number", "false");
|
|
textNodeSelect.refreshAffichage(nod);
|
|
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Ajoute ou modifie un saut de ligne à true.
|
|
*/
|
|
private AbstractAction actsauttrue = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "true" );
|
|
putValue( Action.SHORT_DESCRIPTION, "true" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
textNodeSelect.setContentType("text/html");
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
TreeNode[] chemin = selectNode.getPath();
|
|
boolean avertissement=false;
|
|
for(int i = 0 ; i < chemin.length; i++) {
|
|
if(chemin[i].toString().contains("setting")) avertissement = true;
|
|
System.out.println(chemin[i].toString());
|
|
}
|
|
|
|
if(!avertissement) {
|
|
nod.saut(true);
|
|
textNodeSelect.refreshAffichage(nod);
|
|
// refeshNodeSelected();
|
|
}else {
|
|
JOptionPane.showMessageDialog(null, "Ce node ne peut pas être évaluer." );
|
|
}
|
|
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Ajoute ou modifie un saut de ligne à true.
|
|
*/
|
|
private AbstractAction actsautfalse = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "false" );
|
|
putValue( Action.SHORT_DESCRIPTION, "false" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
textNodeSelect.setContentType("text/html");
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
TreeNode[] chemin = selectNode.getPath();
|
|
boolean avertissement=false;
|
|
for(int i = 0 ; i < chemin.length; i++) {
|
|
if(chemin[i].toString().contains("setting")) avertissement = true;
|
|
System.out.println(chemin[i].toString());
|
|
}
|
|
|
|
if(!avertissement) {
|
|
nod.saut(false);
|
|
textNodeSelect.refreshAffichage(nod);
|
|
// refeshNodeSelected();
|
|
}else {
|
|
JOptionPane.showMessageDialog(null, "Ce node ne peut pas être évaluer." );
|
|
}
|
|
|
|
}
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
*
|
|
*/
|
|
private AbstractAction actPaste = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Coller" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon( getClass().getResource("/paste.png") ) );
|
|
putValue( Action.MNEMONIC_KEY, KeyEvent.VK_P );
|
|
putValue( Action.SHORT_DESCRIPTION, "Coller (CTRL+V)" );
|
|
putValue( Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_V, KeyEvent.CTRL_DOWN_MASK ) );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
System.out.println( "Paste" );
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Affiche la fenêtre informaton sur la version
|
|
*/
|
|
private AbstractAction actAPropos = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Informations" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/aproposmini.png")) );
|
|
putValue( Action.MNEMONIC_KEY, KeyEvent.VK_M );
|
|
putValue( Action.SHORT_DESCRIPTION, "Informations (CTRL+I)" );
|
|
putValue( Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_I, InputEvent.CTRL_DOWN_MASK) );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
new about();
|
|
System.out.println( "A propos" );
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Supprime un node
|
|
*/
|
|
private AbstractAction actDeleteNode = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Supprime" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/supprimemini.png")) );
|
|
putValue( Action.SHORT_DESCRIPTION, "Supprime" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
textNodeSelect.setContentType("text/html");
|
|
|
|
if(tree.getSelectionPath()!=null) {
|
|
int a = JOptionPane.showConfirmDialog(null,"Voulez-vous supprimer le node " + selectNode.toString() + "?", "Sélectionner un choix", JOptionPane.YES_NO_OPTION);
|
|
|
|
if(a == JOptionPane.YES_NO_OPTION) {
|
|
node nod = (node) selectNode.getUserObject();
|
|
if(!(nod.getNomElt().equals("setting")||nod.getNomElt().equals("csv")||nod.getNomElt().equals("import_moodle")||nod.getNomElt().equals("zip")
|
|
||nod.getNomElt().equals("plagiarism")||nod.getNomElt().equals("text:similarity")||nod.getNomElt().equals("color") ||nod.getNomElt().equals("translation") )) {
|
|
|
|
nod.getParent().supprimeNodeEnfant(nod);
|
|
constructionTree();
|
|
|
|
}else {
|
|
JOptionPane.showMessageDialog(null,"Vous ne devez pas supprimer ce node !", "Oh non!!!", JOptionPane.INFORMATION_MESSAGE);
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
};
|
|
|
|
/**
|
|
* evaluer =true
|
|
*/
|
|
private AbstractAction actEvalueTrue = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_E, InputEvent.ALT_DOWN_MASK));
|
|
putValue( Action.NAME, "Evaluer true" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/evaluertruemini.png")) );
|
|
putValue( Action.SHORT_DESCRIPTION, "Evaluer ce node par l'application" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
textNodeSelect.setContentType("text/html");
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
|
|
if(!nod.chemin().contains("setting")) {
|
|
nod.evaluerTrue();
|
|
if(nod.getLevel()==1) {
|
|
nod.addMenu(true);
|
|
}
|
|
|
|
textNodeSelect.refreshAffichage(nod);
|
|
|
|
}else {
|
|
JOptionPane.showMessageDialog(null, "Ce node ne peut pas être évaluer." );
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
|
|
/**
|
|
* addMenu=true
|
|
*/
|
|
private AbstractAction actAddMenuTrue = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "true" );
|
|
putValue( Action.SHORT_DESCRIPTION, "true" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
|
|
if(!nod.chemin().contains("setting")) {
|
|
nod.addMenu(true);
|
|
textNodeSelect.refreshAffichage(nod);;
|
|
}else {
|
|
JOptionPane.showMessageDialog(null, "Ce node ne peut pas contenir de lien de menu." );
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* addMenu=false
|
|
*/
|
|
private AbstractAction actAddMenuFalse = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "false" );
|
|
putValue( Action.SHORT_DESCRIPTION, "false" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
if(!nod.chemin().contains("setting")) {
|
|
nod.addMenu(false);
|
|
textNodeSelect.refreshAffichage(nod);
|
|
}else {
|
|
JOptionPane.showMessageDialog(null, "Ce node ne peut pas contenir de lien de menu." );
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
|
|
// public static void expandOrCollapsePath (JTree tree,TreePath treePath,int level,int currentLevel,boolean expand) {
|
|
// System.out.println("Exp level="+currentLevel+", exp="+expand + ", level=" + level);
|
|
// if (expand && level<=currentLevel && level>0) return;
|
|
//
|
|
// TreeNode treeNode = ( TreeNode ) treePath.getLastPathComponent();
|
|
// TreeModel treeModel=tree.getModel();
|
|
// if ( treeModel.getChildCount(treeNode) >= 0 ) {
|
|
// for ( int i = 0; i < treeModel.getChildCount(treeNode); i++ ) {
|
|
// TreeNode n = ( TreeNode )treeModel.getChild(treeNode, i);
|
|
// TreePath path = treePath.pathByAddingChild( n );
|
|
// expandOrCollapsePath(tree,path,level,currentLevel+1,expand);
|
|
// }
|
|
// if (!expand && currentLevel<level) return;
|
|
// }
|
|
// if (expand) {
|
|
// tree.expandPath( treePath );
|
|
//// System.err.println("Path expanded at level "+currentLevel+"-"+treePath);
|
|
// } else {
|
|
// tree.collapsePath(treePath);
|
|
//// System.err.println("Path collapsed at level "+currentLevel+"-"+treePath);
|
|
// }
|
|
// }
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
*
|
|
*/
|
|
private AbstractAction actDocumentation = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Documentation" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/documentationmini.png")) );
|
|
putValue( Action.MNEMONIC_KEY, KeyEvent.VK_D );
|
|
putValue( Action.SHORT_DESCRIPTION, "Documentation (CTRL+D)" );
|
|
putValue( Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_D, InputEvent.CTRL_DOWN_MASK) );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
Desktop d = Desktop.getDesktop();
|
|
try {
|
|
d.open(new File(create.class.getResource("/resources/documentation.pdf").getPath()));
|
|
} catch (IOException e1) {
|
|
e1.printStackTrace();
|
|
}
|
|
System.out.println( "Affiche la documentation." );
|
|
}
|
|
};
|
|
|
|
private AbstractAction actTutoriels = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Tutoriels" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/tutorielmini.png")) );
|
|
putValue( Action.SHORT_DESCRIPTION, "Tutoriels" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
try {
|
|
String url = "https://www.youtube.com/channel/UCBSfItcCVnbRJdQbVE9ppjQ";
|
|
java.awt.Desktop.getDesktop().browse(java.net.URI.create(url));
|
|
}
|
|
catch (java.io.IOException e1) {
|
|
System.out.println(e1.getMessage());
|
|
}
|
|
System.out.println( "Affiche les tutoriels." );
|
|
}
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* N'évalue pas le node evaluer=false
|
|
*/
|
|
private AbstractAction actEvalueFalse = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_E, InputEvent.ALT_DOWN_MASK | InputEvent.SHIFT_DOWN_MASK));
|
|
putValue( Action.NAME, "Evaluer false" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/evaluerfalsemini.png")) );
|
|
putValue( Action.SHORT_DESCRIPTION, "Ne pas évaluer ce node par l'application." );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
textNodeSelect.setContentType("text/html");
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
if(!nod.chemin().contains("setting")) {
|
|
nod.evaluerFalse();
|
|
textNodeSelect.refreshAffichage(nod);
|
|
}else {
|
|
JOptionPane.showMessageDialog(null, "Ce node ne peut être évalué.");
|
|
}
|
|
|
|
}
|
|
};
|
|
/**
|
|
* Evalue le node est les enfants suivant c'est tout
|
|
*/
|
|
private AbstractAction actEvaluerTousEnfantsTrue = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Evaluer toute la branche" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/evaluertouslesenfantsmini.png")) );
|
|
putValue( Action.LARGE_ICON_KEY, new ImageIcon(create.class.getResource("/resources/evaluertouslesenfants.png")) );
|
|
putValue( Action.SHORT_DESCRIPTION, "Evaluer toute la branche de la racine à la feuille." );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
textNodeSelect.setContentType("text/html");
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
if(!nod.chemin().contains("setting")) {
|
|
nod.evaluerAllChildTrue();
|
|
textNodeSelect.refreshAffichage(nod);
|
|
}else {
|
|
JOptionPane.showMessageDialog(null, "Ce node ne peut être évalué.");
|
|
}
|
|
|
|
}
|
|
};
|
|
|
|
/**
|
|
* N'évalue pas le node est les enfants suivant c'est tout
|
|
*/
|
|
private AbstractAction actEvaluerTousEnfantsFalse = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Evaluer toute la branche" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/evaluertouslesenfantsmini.png")) );
|
|
putValue( Action.LARGE_ICON_KEY, new ImageIcon(create.class.getResource("/resources/evaluertouslesenfants.png")) );
|
|
putValue( Action.SHORT_DESCRIPTION, "Evaluer toute la branche de la racine à la feuille." );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
textNodeSelect.setContentType("text/html");
|
|
|
|
node nod = (node) selectNode.getUserObject();
|
|
if(!nod.chemin().contains("setting")) {
|
|
nod.evaluerAllChildFalse();
|
|
textNodeSelect.refreshAffichage(nod);
|
|
}else {
|
|
JOptionPane.showMessageDialog(null, "Ce node ne peut être évalué.");
|
|
}
|
|
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Expand all
|
|
*/
|
|
private AbstractAction actExpandAll= new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Tout étendre" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/expandallmini.png")) );
|
|
putValue( Action.SHORT_DESCRIPTION, "Tout étendre" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
expandAll();
|
|
|
|
// refeshNodeSelected();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Calloapse all
|
|
*/
|
|
private AbstractAction actCollapseAll= new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Tout réduire" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/collapseallmini.png")) );
|
|
putValue( Action.SHORT_DESCRIPTION, "Tout réduire" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
collapseAll();
|
|
|
|
// refeshNodeSelected();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Expand node
|
|
*/
|
|
private AbstractAction actExpandNode= new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Etendre ce node" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/expandnodemini.png")) );
|
|
putValue( Action.SHORT_DESCRIPTION, "Etendre ce node" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
if(tree.getSelectionPath()!=null) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
textNodeSelect.setContentType("text/html");
|
|
|
|
expandNode(selectNode);
|
|
// refeshNodeSelected();
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Collapse node
|
|
*/
|
|
private AbstractAction actCollapseNode= new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Réduire ce node" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/collapsenodemini.png")) );
|
|
putValue( Action.SHORT_DESCRIPTION, "Réduire ce node" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
if(tree.getSelectionPath()!=null) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
textNodeSelect.setContentType("text/html");
|
|
collapseNode(selectNode);
|
|
// refeshNodeSelected();
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Up node
|
|
*/
|
|
private AbstractAction actUpNode= new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Monter le node" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/upnodemini.png")) );
|
|
putValue( Action.SHORT_DESCRIPTION, "Monter le node" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
if(tree.getSelectionPath()!=null) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
int a = JOptionPane.showConfirmDialog(null,"Voulez-vous monter le node " + selectNode.toString() + "?", "Sélectionner un choix", JOptionPane.YES_NO_OPTION);
|
|
|
|
if(a == JOptionPane.YES_NO_OPTION) {
|
|
node nod = (node) selectNode.getUserObject();
|
|
if(!nod.chemin().contains("setting")) {
|
|
nod.getParent().upNodeEnfant(nod);
|
|
constructionTree();
|
|
}else {
|
|
JOptionPane.showMessageDialog(null,"Vous ne devez pas déplacer ce node !", "Oh non!!!", JOptionPane.INFORMATION_MESSAGE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
*
|
|
*/
|
|
private AbstractAction actDownNode= new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Descendre le node" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(create.class.getResource("/resources/downnodemini.png")) );
|
|
putValue( Action.SHORT_DESCRIPTION, "Descendre le node" );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
if(tree.getSelectionPath()!=null) {
|
|
DefaultMutableTreeNode selectNode = (DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
|
|
|
|
int a = JOptionPane.showConfirmDialog(null,"Voulez-vous descendre le node " + selectNode.toString() + "?", "Sélectionner un choix", JOptionPane.YES_NO_OPTION);
|
|
|
|
if(a == JOptionPane.YES_NO_OPTION) {
|
|
node nod = (node) selectNode.getUserObject();
|
|
if(!nod.chemin().contains("setting")) {
|
|
nod.getParent().downNodeEnfant(nod);
|
|
constructionTree();
|
|
}else {
|
|
JOptionPane.showMessageDialog(null,"Vous ne devez pas déplacer ce node !", "Oh non!!!", JOptionPane.INFORMATION_MESSAGE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Gènère un nouveau fichier d'analyse à partir d'un fichier ODF
|
|
*/
|
|
private AbstractAction actNewFichierAnalyse = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue(Action.LARGE_ICON_KEY, new ImageIcon(evaluate.class.getResource("/resources/fichierODF.png")));
|
|
putValue( Action.NAME, "Génère un nouveau fichier d'analyse" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon(evaluate.class.getResource("/resources/fichierODFmini.png")) );
|
|
putValue( Action.MNEMONIC_KEY, KeyEvent.VK_N );
|
|
putValue( Action.SHORT_DESCRIPTION, "Générer un nouveau fichier d'analyse (CTRL+N)" );
|
|
putValue( Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_N, InputEvent.CTRL_DOWN_MASK) );
|
|
}
|
|
|
|
@Override
|
|
public void actionPerformed( ActionEvent e ) {
|
|
JFileChooser chooser = new JFileChooser();
|
|
chooser.setDialogTitle("Choisir un fichier ODF");
|
|
|
|
chooser.setCurrentDirectory(new java.io.File(commandes.path));
|
|
chooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
|
|
FileNameExtensionFilter filter = new FileNameExtensionFilter("Format ODF", "odt");
|
|
chooser.setFileFilter(filter);
|
|
chooser.setAcceptAllFileFilterUsed(true);
|
|
|
|
if (chooser.showOpenDialog(null) == JFileChooser.APPROVE_OPTION) {
|
|
System.out.println("getCurrentDirectory(): " + chooser.getCurrentDirectory());
|
|
System.out.println("getSelectedFile() : " + chooser.getSelectedFile().getAbsolutePath());
|
|
|
|
commandes.path = chooser.getCurrentDirectory().getAbsolutePath();
|
|
commandes.PathFilenameAnalysis = chooser.getCurrentDirectory().getAbsolutePath();
|
|
String cheminVersFichier = chooser.getSelectedFile().getAbsolutePath();
|
|
commandes.nameSujet = chooser.getSelectedFile().getName();
|
|
|
|
Run b = null;
|
|
try {
|
|
b = new Run(cheminVersFichier);
|
|
commandes.sujet = Run.XMLContent(b.getLectDossiers().getEC().getListeContentWriter().get(0));
|
|
|
|
commandes.sujet = meptl.LectureFichierEtudiantSousFormeDeNode(commandes.sujet,b,0);
|
|
commandes.sujet.getAttributs().put("analysis_filename","sujet.xml");
|
|
|
|
commandes.sujet = ecritureSujet.nodePourEcritureSujet(commandes.sujet,b,0);
|
|
|
|
commandes.sujet.supprimeTousLesNodesEnfantWithThisName("text:change-start");
|
|
commandes.sujet.supprimeTousLesNodesEnfantWithThisName("text:change-end");
|
|
|
|
commandes.sujetSauvegarde = commandes.sujet.clone();
|
|
|
|
new verificationFichierAnalyse();
|
|
|
|
|
|
if(commandes.fichierAnalyseValide) {
|
|
constructionTree();
|
|
textNodeSelect.afficheChargementFichierAnalyse();
|
|
}else {
|
|
textNodeSelect.setText("<h1>Le fichier n'est pas valise</h1>");
|
|
}
|
|
|
|
} catch (ParserConfigurationException | SAXException | IOException | CloneNotSupportedException e1) {
|
|
e1.printStackTrace();
|
|
}
|
|
|
|
} else {
|
|
textNodeSelect.refreshAffichage(null);
|
|
}
|
|
|
|
|
|
commandes.ecritCode = true;
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
*
|
|
*/
|
|
private AbstractAction actEvaluer = new AbstractAction() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
{
|
|
putValue( Action.NAME, "Evaluer" );
|
|
putValue( Action.SMALL_ICON, new ImageIcon( getClass().getResource("/evaluate.png") ) );
|
|
putValue( Action.MNEMONIC_KEY, KeyEvent.VK_E );
|
|
putValue( Action.SHORT_DESCRIPTION, "Evaluer un node (CTRL+E)" );
|
|
putValue( Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_E, KeyEvent.CTRL_DOWN_MASK) );
|
|
}
|
|
|
|
@Override public void actionPerformed( ActionEvent e ) {
|
|
new evaluate();
|
|
dispose();
|
|
}
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* Construction du Tree avec le node sujet.
|
|
*/
|
|
public void constructionTree() {
|
|
|
|
Run.parentAndLevel(commandes.sujet, commandes.sujet, 0);
|
|
|
|
DefaultMutableTreeNode root = null;
|
|
|
|
commandes.tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
|
|
commandes.tree.setExpandsSelectedPaths(true);
|
|
commandes.tree.setInvokesStopCellEditing(true);
|
|
|
|
tree.setExpandsSelectedPaths(true);
|
|
tree.setInvokesStopCellEditing(true);
|
|
|
|
//Construction si c'est un fichier d'analyse
|
|
if(commandes.sujet.getNomElt().equals("fichier")) {
|
|
root = new DefaultMutableTreeNode(commandes.sujet,true);
|
|
root = addNodeMutable(commandes.sujet, root);
|
|
|
|
commandes.tree = new JTree(root);
|
|
|
|
DefaultTreeCellRenderer cellRenderer = (DefaultTreeCellRenderer) commandes.tree.getCellRenderer();
|
|
|
|
|
|
cellRenderer.setOpenIcon(new ImageIcon(create.class.getResource("/resources/treeOpen.png")));
|
|
cellRenderer.setClosedIcon(new ImageIcon(create.class.getResource("/resources/treeClose.png")));
|
|
cellRenderer.setLeafIcon(new ImageIcon(create.class.getResource("/resources/treeLeaf.png")));
|
|
|
|
cellRenderer.setBackgroundNonSelectionColor(new Color(255, 255, 221));
|
|
cellRenderer.setBackgroundSelectionColor(new Color(0, 0, 128));
|
|
cellRenderer.setBorderSelectionColor(Color.black);
|
|
cellRenderer.setTextSelectionColor(Color.white);
|
|
cellRenderer.setTextNonSelectionColor(Color.blue);
|
|
|
|
|
|
tree.setCellRenderer(cellRenderer);
|
|
|
|
// tree.setCellRenderer(new MyTreeCellRenderer());
|
|
|
|
tree.setModel(commandes.tree.getModel()) ;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Permet la construction du tree.
|
|
* @param nod
|
|
* @param parent
|
|
* @return
|
|
*/
|
|
private DefaultMutableTreeNode addNodeMutable(node nod, DefaultMutableTreeNode parent) {
|
|
if(nod!=null) {
|
|
DefaultMutableTreeNode node1 = null;
|
|
for(int i = 0 ; i < nod.getNodes().size(); i++) {
|
|
if(!nod.getNodes().get(i).getNomElt().equals("setting")) {
|
|
node1 = new DefaultMutableTreeNode(nod.getNodes().get(i));
|
|
addNodeMutable(nod.getNodes().get(i), node1);
|
|
parent.add(node1);
|
|
}
|
|
}
|
|
}
|
|
return parent;
|
|
}
|
|
|
|
|
|
/**
|
|
* La balise de style pour le code HTML
|
|
* @return
|
|
*/
|
|
private static String balisestyles() {
|
|
return "<style type=\"text/css\">"
|
|
+ "h1 {margin-bottom: 0.25cm;font-size: 18pt;font-family:\"Arial\";text-align:center;font-weight: bold;}"
|
|
+ "h2 {color:red;margin-bottom: 0.25cm;font-size: 18pt;font-family:\"Arial\";text-align:center;font-weight: bold;}"
|
|
+ "h4 {text-align:left;font-family: \"Arial\"; font-size: 16pt; font-weight: bold; line-height: 110%;}"
|
|
+ "hr { display: block; margin-top: 0.5em; margin-bottom: 8em; margin-left: 2em; margin-right: 2em; border-style: inset; border-width: 4px;}"
|
|
+ "spanpablo { float: right; width: 8em; font-size: 250%; font-family: algerian, courier; line-height: 80%; margin-right: 1%; color: red; text-align: center}"
|
|
+ "p.p1{color:blue;font-family:\"Arial\";font-size: 14pt;margin-bottom: 0cm; margin-top: 0cm; line-height: 0%; background: transparent; margin-left: 0cm; white-space: pre;}"
|
|
+ "li.p2{color:green;font-family:\"Arial\";font-size: 14pt;margin-bottom: 0cm; margin-top: 0cm; line-height: 0%; background: transparent; margin-left: 0cm; white-space: pre;}"
|
|
+ "li.p3{color:red;font-family:\"Arial\";font-size: 14pt;margin-bottom: 0cm; margin-top: 0cm; line-height: 0%; background: transparent; margin-left: 0cm; white-space: pre;}"
|
|
|
|
+ "p.p4{margin-left: 0px; margin-bottom: 0cm; margin-top: 4px; line-height: 115%}"
|
|
+ "</style>";
|
|
}
|
|
|
|
|
|
private void expandAll() {
|
|
Enumeration<?> topLevelNodes = ((TreeNode) tree.getModel().getRoot()).children();
|
|
while(topLevelNodes.hasMoreElements()) {
|
|
DefaultMutableTreeNode N = (DefaultMutableTreeNode) topLevelNodes.nextElement();
|
|
tree.expandPath(new TreePath(N.getPath()));
|
|
expandNode( N);
|
|
}
|
|
}
|
|
|
|
private void collapseAll() {
|
|
Enumeration<?> topLevelNodes = ((TreeNode) tree.getModel().getRoot()).children();
|
|
while(topLevelNodes.hasMoreElements()) {
|
|
DefaultMutableTreeNode N = (DefaultMutableTreeNode) topLevelNodes.nextElement();
|
|
tree.collapsePath(new TreePath(N.getPath()));
|
|
collapseNode(N);
|
|
}
|
|
}
|
|
|
|
private void expandNode(DefaultMutableTreeNode N) {
|
|
Enumeration<?> topLevelNodes = ((TreeNode) N).children();
|
|
while(topLevelNodes.hasMoreElements()) {
|
|
DefaultMutableTreeNode N1 = (DefaultMutableTreeNode) topLevelNodes.nextElement();
|
|
tree.expandPath(new TreePath(N1.getPath()));
|
|
expandNode(N1);
|
|
}
|
|
}
|
|
|
|
private void collapseNode(DefaultMutableTreeNode N) {
|
|
Enumeration<?> topLevelNodes = ((TreeNode) N).children();
|
|
while(topLevelNodes.hasMoreElements()) {
|
|
DefaultMutableTreeNode N1 = (DefaultMutableTreeNode) topLevelNodes.nextElement();
|
|
tree.collapsePath(new TreePath(N1.getPath()));
|
|
collapseNode( N1 );
|
|
}
|
|
tree.collapsePath(new TreePath(N.getPath()));
|
|
}
|
|
|
|
|
|
// void saySomething(String eventDescription, TreeExpansionEvent e) {
|
|
// System.out.println(eventDescription + "; " + "path = " + e.getPath());
|
|
// }
|
|
//
|
|
//
|
|
// // Required by TreeExpansionListener interface.
|
|
// public void treeExpanded(TreeExpansionEvent e) {
|
|
// saySomething("Tree-expanded event detected", e);
|
|
// }
|
|
//
|
|
// // Required by TreeExpansionListener interface.
|
|
// public void treeCollapsed(TreeExpansionEvent e) {
|
|
// saySomething("Tree-collapsed event detected", e);
|
|
// }
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//class MyTreeWillExpandListener implements TreeWillExpandListener {
|
|
//
|
|
//
|
|
// public void treeWillExpand(TreeExpansionEvent evt) throws ExpandVetoException {
|
|
// JTree tree = (JTree) evt.getSource();
|
|
//
|
|
// TreePath path = evt.getPath();
|
|
// boolean veto = false;
|
|
// if (veto) {
|
|
// throw new ExpandVetoException(evt);
|
|
// }
|
|
// }
|
|
//
|
|
// public void treeWillCollapse(TreeExpansionEvent evt) throws ExpandVetoException {
|
|
// JTree tree = (JTree) evt.getSource();
|
|
//
|
|
// TreePath path = evt.getPath();
|
|
// boolean veto = false;
|
|
// if (veto) {
|
|
// throw new ExpandVetoException(evt);
|
|
// }
|
|
// }
|
|
//}
|
|
|
|
//class MyTreeExpansionListener implements TreeExpansionListener {
|
|
//
|
|
// public ArrayList<TreePath> Chemin = new ArrayList<TreePath>();
|
|
//
|
|
// public ArrayList<TreePath> getChemin() {
|
|
// return Chemin;
|
|
// }
|
|
//
|
|
// public void setChemin(ArrayList<TreePath> chemin) {
|
|
// Chemin = chemin;
|
|
// }
|
|
//
|
|
// public void treeExpanded(TreeExpansionEvent evt) {
|
|
// TreePath path = evt.getPath();
|
|
// Chemin.add(path);
|
|
// System.out.println("treeExpanded");
|
|
// }
|
|
//
|
|
// public void treeCollapsed(TreeExpansionEvent evt) {
|
|
// TreePath path = evt.getPath();
|
|
// Chemin.remove(path);
|
|
// System.out.println("treeCollapsed");
|
|
//
|
|
// }
|
|
//}
|
|
|