Laboratoire ICAR » Plateforme TXM

<?xml version="1.0" encoding="UTF-8"?>

<classpath>

	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>

	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins">

		<accessrules>

			<accessrule kind="accessible" pattern="**"/>

		</accessrules>

	</classpathentry>

	<classpathentry kind="src" path="src"/>

	<classpathentry kind="lib" path="libs/itext-pdfa-5.5.8.jar"/>

	<classpathentry kind="lib" path="libs/itext-xtra-5.5.8.jar"/>

	<classpathentry kind="lib" path="libs/jcommon-1.0.23.jar"/>

	<classpathentry kind="lib" path="libs/jcommon-xml-1.0.23.jar"/>

	<classpathentry kind="lib" path="libs/xmlworker-5.5.8.jar"/>

	<classpathentry kind="lib" path="libs/itextpdf-5.5.4.jar"/>

	<classpathentry kind="lib" path="libs/glazedlists_java15-1.9.0.jar"/>

	<classpathentry exported="true" kind="con" path="GROOVY_DSL_SUPPORT"/>

	<classpathentry kind="output" path="bin"/>

</classpath>

Manifest-Version: 1.0

Bundle-ManifestVersion: 2

Bundle-Name: %Bundle-Name

Bundle-SymbolicName: AnalecRCP;singleton:=true

Bundle-Version: 1.0.0.qualifier

Bundle-Activator: analecrcp.Activator

Require-Bundle: org.txm.concordance.core;bundle-version="1.0.0",

 org.txm.concordance.rcp;bundle-version="1.0.0",

 org.eclipse.ui,

 org.eclipse.core.runtime,

 org.eclipse.jface,

 org.eclipse.swt,

 org.eclipse.core.expressions;bundle-version="3.4.600",

 org.txm.libs.jfreechart;bundle-version="1.0.17",

 org.txm.rcp;bundle-version="0.7.8",

 org.txm.core;bundle-version="0.7.0",

 org.txm.synopticeditor.rcp;bundle-version="1.0.0",

 org.txm.searchengine.core;bundle-version="1.0.0",

 org.txm.searchengine.cqp.core;bundle-version="1.1.0",

 org.txm.statsengine.r.core;bundle-version="1.0.0",

 org.txm.statsengine.r.rcp;bundle-version="1.0.0"

Bundle-RequiredExecutionEnvironment: JavaSE-1.6

Bundle-ActivationPolicy: lazy

Export-Package: JamaPlus,

 JamaPlus.util,

 analecrcp,

 org.txm.analec.commands,

 visuAnalec,

 visuAnalec.chaines,

 visuAnalec.donnees,

 visuAnalec.elements,

 visuAnalec.fichiers,

 visuAnalec.statistiques,

 visuAnalec.texte,

 visuAnalec.util,

 visuAnalec.vue

Bundle-Vendor: %Bundle-Vendor

<?xml version="1.0" encoding="UTF-8"?>

<projectDescription>

	<name>org.txm.analec.rcp</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

			<name>org.eclipse.jdt.core.javabuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>org.eclipse.pde.ManifestBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>org.eclipse.pde.SchemaBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

		<nature>org.eclipse.jdt.groovy.core.groovyNature</nature>

		<nature>org.eclipse.pde.PluginNature</nature>

		<nature>org.eclipse.jdt.core.javanature</nature>

	</natures>

</projectDescription>

/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

package visuAnalec;

import java.awt.*;

import java.awt.event.*;

import java.util.ArrayList;

import javax.swing.*;

import visuAnalec.Message.*;

import visuAnalec.PanneauEditeur.*;

import visuAnalec.elements.*;

import visuAnalec.texte.*;

import visuAnalec.texte.PanneauAffTexte.*;

import visuAnalec.texte.PanneauTexte.*;

import visuAnalec.util.*;

import visuAnalec.util.GMessages.*;

import visuAnalec.util.GVisu.*;

import visuAnalec.vue.*;

/**

 *

 * @author Bernard

 */

public class PanneauCommandesRelations extends PanneauCommandes implements ActionListener {

  private PanneauChamps panneauChamps;

  private TypeComboBox saisieTypeRelations;

  private ElementComboBox saisieRelation;

  private TypeComboBox saisieTypeElt1;

  private ElementComboBox saisieElt1;

  private TypeComboBox saisieTypeElt2;

  private ElementComboBox saisieElt2;

  private JButton creeRelation;

  private JButton supprimeRelation;

  private JButton creeUniteElt1;

  private JButton creeUniteElt2;

  private boolean uniteCreeElt1 = true; // pour la création d'unités en cours de route

  private int[] bornesSelectTexte;

  /*

   * CREATION PAR LE PANNEAU EDITEUR

   */

  PanneauCommandesRelations(Vue vue, PanneauAffTexte pTexte, PanneauChamps pChamps) {

    super(vue, pTexte);

    JToolBar barre1 = new JToolBar();

    barre1.setPreferredSize(new Dimension(0, 22));

    barre1.setAlignmentX(0.0f);

    //    barre1.setFloatable(false);

    add(barre1);

    JToolBar barre2 = new JToolBar();

//    barre2.setBackground(PanneauTexte.getCouleurFond2());

    barre2.setPreferredSize(new Dimension(0, 22));

    barre2.setAlignmentX(0.0f);

//     barre2.setFloatable(false);

    add(barre2);

    JToolBar barre3 = new JToolBar();

    barre3.setPreferredSize(new Dimension(0, 22));

    barre3.setAlignmentX(0.0f);

//    barre3.setBackground(PanneauTexte.getCouleurFond2());

//     barre3.setFloatable(false);

    add(barre3);

    panneauChamps = pChamps;

    saisieTypeRelations = new TypeComboBox(Relation.class);

    saisieTypeRelations.addActionListener(this);

    saisieRelation = new ElementComboBox();

    saisieRelation.addActionListener(this);

    saisieTypeElt1 = new TypeComboBox(Element.class);

    saisieTypeElt1.addActionListener(this);

    saisieElt1 = new ElementComboBox();

    saisieElt1.addActionListener(this);

    saisieTypeElt2 = new TypeComboBox(Element.class);

    saisieTypeElt2.addActionListener(this);

    saisieElt2 = new ElementComboBox();

    saisieElt2.addActionListener(this);

    creeRelation = new JButton(new GAction("Créer") {

      public void executer() {

        creerRelation();

      }

    });

    supprimeRelation = new JButton(new GAction("Supprimer") {

      public void executer() {

        supprimerRelation();

      }

    });

    creeUniteElt1 = new JButton(new GAction("Créer") {

      public void executer() {

        creerUniteElt1();

      }

    });

    creeUniteElt2 = new JButton(new GAction("Créer") {

      public void executer() {

        creerUniteElt2();

      }

    });

    barre1.addSeparator();

    barre1.add(new TitreBarre("  Relation :  ", PanneauTexte.getCouleurFond1()));

    barre1.addSeparator();

    barre1.add(saisieTypeRelations);

    barre1.add(saisieRelation);

    barre1.addSeparator();

    barre1.add(creeRelation);

    barre1.addSeparator();

    barre1.add(supprimeRelation);

    barre2.addSeparator();

    barre2.add(new TitreBarre("Elément 1 : ", PanneauTexte.getCouleurFond2()));

    barre2.addSeparator();

    barre2.add(saisieTypeElt1);

    barre2.add(saisieElt1);

    barre2.addSeparator();

    barre2.add(creeUniteElt1);

    barre3.addSeparator();

    barre3.add(new TitreBarre("Elément 2 : ", PanneauTexte.getCouleurFond3()));

    barre3.addSeparator();

    barre3.add(saisieTypeElt2);

    barre3.add(saisieElt2);

    barre3.addSeparator();

    barre3.add(creeUniteElt2);

  }

  /*

   * COMMANDES UTILISEES PAR LE PANNEAU EDITEUR

   */

  public void reinitialiser() {

    // typiquement, appelé par le panneau éditeur à la suite d'une modif de vue ou de structure

    saisieTypeRelations.removeActionListener(this);

    saisieTypeRelations.setModele(vue.getTypesRelationsAVoir());

    saisieTypeRelations.effSelection();

    saisieTypeRelations.addActionListener(this);

    saisieTypeElt1.removeActionListener(this);

    saisieTypeElt1.setModele(vue.getTypes(Unite.class), vue.getTypes(Relation.class), vue.getTypes(Schema.class));

    saisieTypeElt1.effSelection();

    saisieTypeElt1.addActionListener(this);

    saisieTypeElt2.removeActionListener(this);

    saisieTypeElt2.setModele(vue.getTypes(Unite.class), vue.getTypes(Relation.class), vue.getTypes(Schema.class));

    saisieTypeElt2.effSelection();

    saisieTypeElt2.addActionListener(this);

    initSaisieRelation();

    initSaisieElt1();

    initSaisieElt2();

    etatSelectRien();

    revalidate();

    repaint();

  }

  public void reafficher() {

    // potentiellement appelé par le panneau éditeur ?

    // appelé aussi par  traiterElementEvent

    if (saisieRelation.pasdeSelection()) {

      initSaisieRelation();

      if (saisieElt1.pasdeSelection()) {

        initSaisieElt1();

        if (saisieElt2.pasdeSelection()) {

          initSaisieElt2();

          etatSelectRien();

        } else {

          Element elt2Courant = saisieElt2.getSelection();

          initSaisieElt2(elt2Courant);

          etatSelectElt2(elt2Courant);

        }

      } else {

        Element elt1Courant = saisieElt1.getSelection();

        initSaisieElt1(elt1Courant);

        if (saisieElt2.pasdeSelection()) {

          initSaisieElt2();

          etatSelectElt1(elt1Courant);

        } else {

          Element elt2Courant = saisieElt2.getSelection();

          initSaisieElt2(elt2Courant);

          etatSelectElts(elt1Courant, elt2Courant);

        }

      }

    } else {

      Relation relCourant = (Relation) saisieRelation.getSelection();

      initSaisieRelation(relCourant);

      initSaisieElt1(relCourant.getElt1());

      initSaisieElt2(relCourant.getElt2());

      etatSelectRel(relCourant);

    }

  }

  public void elementSuivant(int sens) {

    if (sens>0) saisieRelation.gotoSuivant();

    else saisieRelation.gotoPrecedent();

  }

 public Element elementSelectionne() {

    if (saisieRelation.pasdeSelection()) return null;

    return saisieRelation.getSelection();

  }

  public void editerElement(Element elt) {

    // appelé par le panneauEditeur : elt est forcément une relation

    if (elt.getClass()!=Relation.class)

      throw new UnsupportedOperationException("Erreur : classe incorrecte");

    editerRelation((Relation) elt);

  }

  public void traiterElementEvent(ElementEvent evt) {

    switch (evt.getModif()) {

      case AJOUT_RELATION:

        Relation rel = (Relation) evt.getElement();

        editerRelation(rel);

        return;

      case SUP_RELATION:

        if (evt.getElement()==saisieRelation.getSelection()) {

          initSaisieRelation();

          initSaisieElt1();

          initSaisieElt2();

          etatSelectRien();

        } else {

          reafficher();

        }

        return;

      case AJOUT_UNITE:

        Unite unit = (Unite) evt.getElement();

        boolean chgEtat = false;

        if (!saisieTypeElt1.pasdeSelection()&&saisieTypeElt1.getClasseSelection()==Unite.class

                &&saisieTypeElt1.getTypeSelection().equals(unit.getType())) {

          initSaisieElt1(uniteCreeElt1 ? unit : null);

          chgEtat = true;

        }

        if (!saisieTypeElt2.pasdeSelection()&&saisieTypeElt2.getClasseSelection()==Unite.class

                &&saisieTypeElt2.getTypeSelection().equals(unit.getType())) {

          initSaisieElt2(uniteCreeElt1 ? null : unit);

          chgEtat = true;

        }

        if (chgEtat) {

          if (uniteCreeElt1) etatSelectElt1(unit);

          else etatSelectElt2(unit);

          uniteCreeElt1 = true;

        }

        return;

      case SUP_UNITE:

      case BORNES_UNITE:

      case AJOUT_SCHEMA:

      case MODIF_SCHEMA:

      case SUP_SCHEMA:

      case MODIF_VALEUR:

        reafficher();

        return;

      default:

        throw new UnsupportedOperationException("Cas "+evt.getModif()+" oublié dans un switch");

    }

  }

  public void editerRelation(Relation rel) {

    // appelé  par traiterElementEvent, 

    // et aussi directement par le panneau éditeur quand il est sollicité par d'autres fenêtres

    if (!rel.getType().equals(saisieTypeRelations.getTypeSelection())) {

      saisieTypeRelations.removeActionListener(this);

      saisieTypeRelations.setSelection(rel.getType());

      saisieTypeRelations.addActionListener(this);

    }

    initSaisieRelation(rel);

    saisieRelation.setSelection(rel);

  }

  public ArrayList<ElementMarque> trouverElementsVises(Unite uniteVisee, TypeMarquage marqueUniteVisee,

          boolean avecId) {

    ArrayList<ElementMarque> eltsMarques = new ArrayList<ElementMarque>();

    ArrayList<Element> eltsVises;

    Element eltVise;

    switch (marqueUniteVisee) {

      case FOND1:

        eltsVises = Element.trouverElementsParUniteSousjacente(saisieRelation.getElements(), uniteVisee);

        for (Element elt : eltsVises)

          eltsMarques.add(new ElementMarque(

                  elt, marqueUniteVisee, avecId ? saisieRelation.getIdElement(elt) : null));

        return eltsMarques;

      case FOND2:

        eltsVises = Element.trouverElementsParUniteSousjacente(saisieElt1.getElements(), uniteVisee);

        for (Element elt : eltsVises)

          eltsMarques.add(new ElementMarque(

                  elt, marqueUniteVisee, avecId ? saisieElt1.getIdElement(elt) : null));

        return eltsMarques;

      case FOND3:

        eltsVises = Element.trouverElementsParUniteSousjacente(saisieElt2.getElements(), uniteVisee);

        for (Element elt : eltsVises)

          eltsMarques.add(new ElementMarque(

                  elt, marqueUniteVisee, avecId ? saisieElt2.getIdElement(elt) : null));

        return eltsMarques;

      case SELECT2:

      case SELECT1_2:

        eltVise = saisieElt1.getSelection();

        eltsMarques.add(new ElementMarque(

                eltVise, marqueUniteVisee, avecId ? saisieElt1.getIdElement(eltVise) : null));

        return eltsMarques;

      case SELECT3:

      case SELECT1_3:

        eltVise = saisieElt2.getSelection();

        eltsMarques.add(new ElementMarque(

                eltVise, marqueUniteVisee, avecId ? saisieElt2.getIdElement(eltVise) : null));

        return eltsMarques;

      default:

        throw new UnsupportedOperationException("Marquage non prévu : "+marqueUniteVisee);

    }

  }

  /*

   * ACTIONS DE L'UTILISATEUR : CHANGEMENTS D'ETAT

   */

  public void actionPerformed(ActionEvent evt) {

    try {

      if (evt.getSource()==saisieTypeRelations) {

        initSaisieRelation();

        if (saisieElt1.pasdeSelection()) {

          if (saisieElt2.pasdeSelection()) etatSelectRien();

          else etatSelectElt2(saisieElt2.getSelection());

        } else {

          if (saisieElt2.pasdeSelection())

            etatSelectElt1(saisieElt1.getSelection());

          else

            checkEtatSelectElts(saisieElt1.getSelection(), saisieElt2.getSelection());

        }

        return;

      }

      if (evt.getSource()==saisieTypeElt1) {

        forceEffSelectRel();

        initSaisieElt1();

        if (saisieElt2.pasdeSelection()) etatSelectRien();

        else etatSelectElt2(saisieElt2.getSelection());

        return;

      }

      if (evt.getSource()==saisieTypeElt2) {

        forceEffSelectRel();

        initSaisieElt2();

        if (saisieElt1.pasdeSelection()) etatSelectRien();

        else etatSelectElt1(saisieElt1.getSelection());

        return;

      }

      if (evt.getSource()==saisieRelation) {

        if (saisieRelation.pasdeSelection()) {

          if (saisieElt1.pasdeSelection()) {

            if (saisieElt2.pasdeSelection()) etatSelectRien();

            else etatSelectElt2(saisieElt2.getSelection());

          } else {

            if (saisieElt2.pasdeSelection())

              etatSelectElt1(saisieElt1.getSelection());

            else

              etatSelectElts(saisieElt1.getSelection(), saisieElt2.getSelection());

          }

        } else {

          forceEtatSelectRel((Relation) saisieRelation.getSelection());

        }

        return;

      }

      if (evt.getSource()==saisieElt1) {

        if (!saisieRelation.pasdeSelection()) {

          saisieRelation.removeActionListener(this);

          saisieRelation.effSelection();

          saisieRelation.addActionListener(this);

          saisieElt2.removeActionListener(this);

          saisieElt2.effSelection();

          saisieElt2.addActionListener(this);

        }

        if (saisieElt1.pasdeSelection()) {

          if (saisieElt2.pasdeSelection()) etatSelectRien();

          else etatSelectElt2(saisieElt2.getSelection());

        } else {

          if (saisieElt2.pasdeSelection())

            etatSelectElt1(saisieElt1.getSelection());

          else

            checkEtatSelectElts(saisieElt1.getSelection(), saisieElt2.getSelection());

        }

        return;

      }

      if (evt.getSource()==saisieElt2) {

        if (!saisieRelation.pasdeSelection()) {

          saisieRelation.removeActionListener(this);

          saisieRelation.effSelection();

          saisieRelation.addActionListener(this);

          saisieElt1.removeActionListener(this);

          saisieElt1.effSelection();

          saisieElt1.addActionListener(this);

        }

        if (saisieElt2.pasdeSelection()) {

          if (saisieElt1.pasdeSelection()) etatSelectRien();

          else etatSelectElt1(saisieElt1.getSelection());

        } else {

          if (saisieElt1.pasdeSelection())

            etatSelectElt2(saisieElt2.getSelection());

          else

            checkEtatSelectElts(saisieElt1.getSelection(), saisieElt2.getSelection());

        }

        return;

      }

      throw new UnsupportedOperationException("Evénement non prévu : "+evt.paramString());

    } catch (Throwable ex) {

      GMessages.erreurFatale(ex);

    }

  }

  @Override

  public void traiterSourisEvent(SourisEvent evt) {

    switch (evt.getTypeEvent()) {

      case SELECT_RIEN:

        saisieElt1.removeActionListener(this);

        saisieElt1.effSelection();

        saisieElt1.addActionListener(this);

        saisieElt2.removeActionListener(this);

        saisieElt2.effSelection();

        saisieElt2.addActionListener(this);

        saisieRelation.removeActionListener(this);

        saisieRelation.effSelection();

        saisieRelation.addActionListener(this);

        etatSelectRien();

        return;

      case SELECT_ELEMENT:

        switch (evt.getMarquageElementVise()) {

          case FOND1:

            saisieRelation.setSelection(evt.getElementVise());

            return;

          case FOND2:

            saisieElt1.setSelection(evt.getElementVise());

            return;

          case FOND3:

            saisieElt2.setSelection(evt.getElementVise());

            return;

          case SELECT2:

          case SELECT1_2:

            forceEffSelectElt2();

            return;

          case SELECT3:

          case SELECT1_3:

            forceEffSelectElt1();

            return;

        }

        return;

      case SELECT_TEXTE:

        if (!saisieElt1.pasdeSelection()&&!saisieElt2.pasdeSelection()) {

          saisieElt1.removeActionListener(this);

          saisieElt1.effSelection();

          saisieElt1.addActionListener(this);

          saisieElt2.removeActionListener(this);

          saisieElt2.effSelection();

          saisieElt2.addActionListener(this);

          saisieRelation.removeActionListener(this);

          saisieRelation.effSelection();

          saisieRelation.addActionListener(this);

        }

        bornesSelectTexte = evt.getBornesSelectionTexte();

        etatSelectTexte();

        return;

    }

    throw new UnsupportedOperationException("Evénement non prévu : "+evt.getTypeEvent());

  }

  /*

   * ACTIONS DE L'UTILISATEUR : BOUTONS

   */

  private void creerRelation() {

    vue.getCorpus().addRelationSaisie((String) saisieTypeRelations.getTypeSelection(),

            saisieElt1.getSelection(), saisieElt2.getSelection());

  }

  private void supprimerRelation() {

    if (!GMessages.confirmationAction("Supprimer la relation sélectionnée ?"))

      return;

    vue.getCorpus().supRelation((Relation) saisieRelation.getSelection());

  }

  private void creerUniteElt1() {

    if (vue.getCorpus().checkPresenceUnite(saisieTypeElt1.getTypeSelection(), bornesSelectTexte[0], bornesSelectTexte[1])

            &&!GMessages.confirmationAction("Dupliquer cette unité  ?")) return;

    uniteCreeElt1 = true;

    vue.getCorpus().addUniteSaisie(saisieTypeElt1.getTypeSelection(), bornesSelectTexte[0], bornesSelectTexte[1]);

  }

  private void creerUniteElt2() {

    if (vue.getCorpus().checkPresenceUnite(saisieTypeElt2.getTypeSelection(), bornesSelectTexte[0], bornesSelectTexte[1])

            &&!GMessages.confirmationAction("Dupliquer cette unité  ?")) return;

    uniteCreeElt1 = false;

    vue.getCorpus().addUniteSaisie(saisieTypeElt2.getTypeSelection(), bornesSelectTexte[0], bornesSelectTexte[1]);

  }

  /* 

   * GESTION INTERNE

   */

  private void etatSelectRien() {   // rien n'est sélectionné

    if (saisieTypeRelations.pasdeSelection()) {

      if (saisieTypeElt1.pasdeSelection()) {

        if (saisieTypeElt2.pasdeSelection()) panneauTexte.pasDeMarquage();

        else

          panneauTexte.saisir(null,

                  Element.getUnitesSousjacentes(saisieElt2.getElements()), TypeMarquage.FOND3);

      } else {

        if (saisieTypeElt2.pasdeSelection())

          panneauTexte.saisir(null,

                  Element.getUnitesSousjacentes(saisieElt1.getElements()), TypeMarquage.FOND2);

        else

          panneauTexte.saisir(null,

                  Element.getUnitesSousjacentes(saisieElt1.getElements()), TypeMarquage.FOND2,

                  Element.getUnitesSousjacentes(saisieElt2.getElements()), TypeMarquage.FOND3);

      }

    } else {

      if (saisieTypeElt1.pasdeSelection()) {

        if (saisieTypeElt2.pasdeSelection())

          panneauTexte.saisir(null,

                  Element.getUnitesSousjacentes(saisieRelation.getElements()), TypeMarquage.FOND1);

        else

          panneauTexte.saisir(null,

                  Element.getUnitesSousjacentes(filtreElt2((Relation[]) saisieRelation.getElements())), TypeMarquage.FOND1,

                  Element.getUnitesSousjacentes(saisieElt2.getElements()), TypeMarquage.FOND3);

      } else {

        if (saisieTypeElt2.pasdeSelection())

          panneauTexte.saisir(null,

                  Element.getUnitesSousjacentes(filtreElt1((Relation[]) saisieRelation.getElements())), TypeMarquage.FOND1,

                  Element.getUnitesSousjacentes(saisieElt1.getElements()), TypeMarquage.FOND2);

        else

          panneauTexte.saisir(null,

                  Element.getUnitesSousjacentes(filtreElts((Relation[]) saisieRelation.getElements())), TypeMarquage.FOND1,

                  Element.getUnitesSousjacentes(saisieElt1.getElements()), TypeMarquage.FOND2,

                  Element.getUnitesSousjacentes(saisieElt2.getElements()), TypeMarquage.FOND3);

      }

    }

    panneauChamps.effacer();

    creeRelation.setEnabled(false);

    supprimeRelation.setEnabled(false);

    creeUniteElt1.setEnabled(false);

    creeUniteElt2.setEnabled(false);

  }

  private void etatSelectTexte() {   // du texte est sélectionné

    if (saisieElt1.pasdeSelection()) {

      if (saisieElt2.pasdeSelection()) panneauTexte.pasDeMarquage();

      else

        panneauTexte.saisir(null,

                saisieElt2.getSelection().getUnitesSousjacentes(), TypeMarquage.SELECT3);

    } else {

      if (saisieElt2.pasdeSelection())

        panneauTexte.saisir(null,

                saisieElt1.getSelection().getUnitesSousjacentes(), TypeMarquage.SELECT2);

      else // au moins un des 2 elt n'est pas sélectionné

        throw new UnsupportedOperationException("Cas non prévu");

    }

    panneauChamps.effacer();

    creeRelation.setEnabled(false);

    supprimeRelation.setEnabled(false);

    if (!saisieTypeElt1.pasdeSelection()&&saisieTypeElt1.getClasseSelection()==Unite.class

            &&saisieElt1.pasdeSelection())

      creeUniteElt1.setEnabled(true);

    if (!saisieTypeElt2.pasdeSelection()&&saisieTypeElt2.getClasseSelection()==Unite.class

            &&saisieElt2.pasdeSelection())

      creeUniteElt2.setEnabled(true);

  }

  private void etatSelectElt1(Element elt1) { // seul Elt1 a été choisi

    if (saisieTypeElt2.pasdeSelection()) {

      if (saisieTypeRelations.pasdeSelection())

        panneauTexte.saisir(elt1.getUnite0(), elt1.getUnitesSousjacentes(), TypeMarquage.SELECT2);

      else

        panneauTexte.saisir(elt1.getUnite0(), elt1.getUnitesSousjacentes(), TypeMarquage.SELECT2,

                Element.getUnitesSousjacentes(filtreElt1((Relation[]) saisieRelation.getElements(), elt1)),

                TypeMarquage.FOND1);

    } else {

      if (saisieTypeRelations.pasdeSelection())

        panneauTexte.saisir(elt1.getUnite0(), elt1.getUnitesSousjacentes(), TypeMarquage.SELECT2,

                Element.getUnitesSousjacentes(saisieElt2.getElements()), TypeMarquage.FOND3);

      else

        panneauTexte.saisir(elt1.getUnite0(), elt1.getUnitesSousjacentes(), TypeMarquage.SELECT2,

                Element.getUnitesSousjacentes(filtreElt1(filtreElt2((Relation[]) saisieRelation.getElements()), elt1)),

                TypeMarquage.FOND1,

                Element.getUnitesSousjacentes(saisieElt2.getElements()), TypeMarquage.FOND3);

    }

    panneauChamps.afficher(elt1);

    creeRelation.setEnabled(false);

    supprimeRelation.setEnabled(false);

    creeUniteElt1.setEnabled(false);

    creeUniteElt2.setEnabled(false);

  }

  private void etatSelectElt2(Element elt2) {  // seul Elt2 a été choisi

    if (saisieTypeElt1.pasdeSelection()) {

      if (saisieTypeRelations.pasdeSelection())

        panneauTexte.saisir(elt2.getUnite0(), elt2.getUnitesSousjacentes(), TypeMarquage.SELECT3);

      else

        panneauTexte.saisir(elt2.getUnite0(), elt2.getUnitesSousjacentes(), TypeMarquage.SELECT3,

                Element.getUnitesSousjacentes(filtreElt2((Relation[]) saisieRelation.getElements(), elt2)),

                TypeMarquage.FOND1);

    } else {

      if (saisieTypeRelations.pasdeSelection())

        panneauTexte.saisir(elt2.getUnite0(), elt2.getUnitesSousjacentes(), TypeMarquage.SELECT3,

                Element.getUnitesSousjacentes(saisieElt1.getElements()), TypeMarquage.FOND2);

      else

        panneauTexte.saisir(elt2.getUnite0(), elt2.getUnitesSousjacentes(), TypeMarquage.SELECT3,

                Element.getUnitesSousjacentes(filtreElt2(filtreElt1((Relation[]) saisieRelation.getElements()), elt2)),

                TypeMarquage.FOND1,

                Element.getUnitesSousjacentes(saisieElt1.getElements()), TypeMarquage.FOND2);

    }

    panneauChamps.afficher(elt2);

    creeRelation.setEnabled(false);

    supprimeRelation.setEnabled(false);

    creeUniteElt1.setEnabled(false);

    creeUniteElt2.setEnabled(false);

  }

  private void etatSelectElts(Element elt1, Element elt2) { // Elt1 et Elt2 ont été choisis et ils ne forment pas encore de relation

    panneauTexte.saisir(elt1.getUnite0(), elt1.getUnitesSousjacentes(), TypeMarquage.SELECT2,

            elt2.getUnitesSousjacentes(), TypeMarquage.SELECT3);

    panneauChamps.effacer();

    if (!saisieTypeRelations.pasdeSelection()) {

      creeRelation.setEnabled(true);

//      Boutons.setDefaut(creeRelation, true);

    }

    supprimeRelation.setEnabled(false);

    creeUniteElt1.setEnabled(false);

    creeUniteElt2.setEnabled(false);

  }

  private void etatSelectRel(Relation rel) {  // une relation est sélectionnée

    panneauTexte.saisir(rel.getElt1().getUnite0(),

            rel.getElt1().getUnitesSousjacentes(), TypeMarquage.SELECT1_2,

            rel.getElt2().getUnitesSousjacentes(), TypeMarquage.SELECT1_3);

//            Element.getUnitesSousjacentes(saisieElt1.getElements()), TypeMarquage.FOND2,

//            Element.getUnitesSousjacentes(saisieElt2.getElements()), TypeMarquage.FOND3);

    panneauChamps.afficher(rel);

    creeRelation.setEnabled(false);

    supprimeRelation.setEnabled(true);

    creeUniteElt1.setEnabled(false);

    creeUniteElt2.setEnabled(false);

  }

  private Relation[] filtreElt1(Relation[] relations) {

    Class classe = saisieTypeElt1.getClasseSelection();

    String type = saisieTypeElt1.getTypeSelection();

    ArrayList<Integer> indsAOter = new ArrayList<Integer>();

    for (int i = 0; i<relations.length; i++) {

      Element elt1 = relations[i].getElt1();

      if (elt1.getClass()!=classe||!elt1.getType().equals(type))

        indsAOter.add(i);

    }

    return Tableaux.oterRelations(relations, indsAOter);

  }

  private Relation[] filtreElt1(Relation[] relations, Element elt1) {

    ArrayList<Relation> rels = new ArrayList<Relation>();

    for (Relation rel : relations) if (elt1==rel.getElt1()) rels.add(rel);

    return rels.toArray(new Relation[0]);

  }

  private Relation[] filtreElt2(Relation[] relations) {

    Class classe = saisieTypeElt2.getClasseSelection();

    String type = saisieTypeElt2.getTypeSelection();

    ArrayList<Integer> indsAOter = new ArrayList<Integer>();

    for (int i = 0; i<relations.length; i++) {

      Element elt2 = relations[i].getElt2();

      if (elt2.getClass()!=classe||!elt2.getType().equals(type))

        indsAOter.add(i);

    }

    return Tableaux.oterRelations(relations, indsAOter);

  }

  private Relation[] filtreElt2(Relation[] relations, Element elt2) {

    ArrayList<Relation> rels = new ArrayList<Relation>();

    for (Relation rel : relations) if (elt2==rel.getElt2()) rels.add(rel);

    return rels.toArray(new Relation[0]);

  }

  private Relation[] filtreElts(Relation[] relations) {

    Class classe1 = saisieTypeElt1.getClasseSelection();

    String type1 = saisieTypeElt1.getTypeSelection();

    Class classe2 = saisieTypeElt2.getClasseSelection();

    String type2 = saisieTypeElt2.getTypeSelection();

    ArrayList<Integer> indsAOter = new ArrayList<Integer>();

    for (int i = 0; i<relations.length; i++) {

      Element elt1 = relations[i].getElt1();

      Element elt2 = relations[i].getElt2();

      if (elt1.getClass()!=classe1||!elt1.getType().equals(type1)

              ||elt2.getClass()!=classe2||!elt2.getType().equals(type2))

        indsAOter.add(i);

    }

    return Tableaux.oterRelations(relations, indsAOter);

  }

  private void checkEtatSelectElts(Element elt1, Element elt2) {

    if (!saisieTypeRelations.pasdeSelection())

      for (Relation rel : (Relation[]) saisieRelation.getElements()) {

        if (rel.getElt1()==elt1&&rel.getElt2()==elt2) {

          saisieRelation.setSelection(rel);

          return;

        }

      }

    etatSelectElts(elt1, elt2);

  }

  private void forceEtatSelectRel(Relation rel) {

    if (saisieTypeElt1.pasdeSelection()||saisieTypeElt1.getClasseSelection()!=rel.getElt1().getClass()

            ||!saisieTypeElt1.getTypeSelection().equals(rel.getElt1().getType())) {

      saisieTypeElt1.removeActionListener(this);

      saisieTypeElt1.setSelection(rel.getElt1().getClass(), rel.getElt1().getType());

      saisieTypeElt1.addActionListener(this);

    }

    initSaisieElt1(rel.getElt1());

    if (saisieTypeElt2.pasdeSelection()||saisieTypeElt2.getClasseSelection()!=rel.getElt2().getClass()

            ||!saisieTypeElt2.getTypeSelection().equals(rel.getElt2().getType())) {

      saisieTypeElt2.removeActionListener(this);

      saisieTypeElt2.setSelection(rel.getElt2().getClass(), rel.getElt2().getType());

      saisieTypeElt2.addActionListener(this);

    }

    initSaisieElt2(rel.getElt2());

    etatSelectRel(rel);

  }

  private void forceEffSelectElt1() {

    if (saisieElt1.pasdeSelection()) return;

    if (!saisieRelation.pasdeSelection()) {

      saisieRelation.removeActionListener(this);

      saisieRelation.effSelection();

      saisieRelation.addActionListener(this);

    }

    saisieElt1.effSelection();

  }

  private void forceEffSelectElt2() {

    if (saisieElt2.pasdeSelection()) return;

    if (!saisieRelation.pasdeSelection()) {

      saisieRelation.removeActionListener(this);

      saisieRelation.effSelection();

      saisieRelation.addActionListener(this);

    }

    saisieElt2.effSelection();

  }

  private void forceEffSelectRel() {

    if (saisieRelation.pasdeSelection()) return;

    saisieRelation.removeActionListener(this);

    saisieRelation.effSelection();

    saisieRelation.addActionListener(this);

  }

  private void initSaisieRelation(Relation rel) {

    saisieRelation.removeActionListener(this);

    if (saisieTypeRelations.pasdeSelection()) saisieRelation.setModeleVide();

    else {

      String type0 = saisieTypeRelations.getTypeSelection();

      Relation[] relations = vue.getRelationsAVoir(type0);

      saisieRelation.setModele(relations, vue.getIdRelations(type0, relations));

    }

    if (rel==null) saisieRelation.effSelection();

    else saisieRelation.setSelection(rel);

    saisieRelation.addActionListener(this);

    saisieRelation.revalidate();

  }

  private void initSaisieRelation() {

    initSaisieRelation(null);

  }

  private void initSaisieElt1(Element elt1) {

    saisieElt1.removeActionListener(this);

    if (saisieTypeElt1.pasdeSelection()) saisieElt1.setModeleVide();

    else {

      Class<? extends Element> classe = saisieTypeElt1.getClasseSelection();

      String type = saisieTypeElt1.getTypeSelection();

      saisieElt1.setModele(vue.getElements(classe, type), vue.getIdElements(classe, type));

    }

    if (elt1==null) saisieElt1.effSelection();

    else saisieElt1.setSelection(elt1);

    saisieElt1.addActionListener(this);

    saisieElt1.revalidate();

  }

  private void initSaisieElt1() {

    initSaisieElt1(null);

  }

  private void initSaisieElt2(Element elt2) {

    saisieElt2.removeActionListener(this);

    if (saisieTypeElt2.pasdeSelection()) saisieElt2.setModeleVide();

    else {

      Class<? extends Element> classe = saisieTypeElt2.getClasseSelection();

      String type = saisieTypeElt2.getTypeSelection();

      saisieElt2.setModele(vue.getElements(classe, type), vue.getIdElements(classe, type));

    }

    if (elt2==null) saisieElt2.effSelection();

    else saisieElt2.setSelection(elt2);

    saisieElt2.addActionListener(this);

    saisieElt2.revalidate();

  }

  private void initSaisieElt2() {

    initSaisieElt2(null);

  }

}

/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

package visuAnalec.vue;

import JamaPlus.*;

import java.io.*;

import java.util.*;

import java.util.ArrayList;

import javax.swing.text.SimpleAttributeSet;

import visuAnalec.*;

import visuAnalec.util.*;

import visuAnalec.Message.*;

import visuAnalec.elements.*;

import visuAnalec.donnees.*;

import visuAnalec.donnees.Corpus.*;

import visuAnalec.texte.PanneauTexte;

import visuAnalec.texte.PanneauTexte.*;

/**

 *

 * @author Bernard

 */

public class Vue implements CorpusListener {

  public static interface VueListener extends EventListener {

    void traiterEvent(Message e);     // relaie les messages de Corpus + envoie ses propres messages (VueEvent)

  }

  public static class Adresse implements Serializable {

    ArrayList<Jalon> chemin;

    String prop;

    Adresse(Adresse adresse, String prop) {

      this.prop = prop;

      this.chemin = new ArrayList<Jalon>(adresse.chemin);

    }

    Adresse(Adresse adresse, Jalon jalon) {

      this.prop = null;

      ArrayList<Jalon> chemin1 = new ArrayList<Jalon>(adresse.chemin);

      chemin1.add(jalon);

      this.chemin = chemin1;

    }

    Adresse(Adresse adresse) {

      this.prop = adresse.prop;

      this.chemin = new ArrayList<Jalon>();

      for (Jalon jalon : adresse.chemin) this.chemin.add(new Jalon(jalon));

    }

    Adresse(Jalon jalon, String prop) {

      this.prop = prop;

      chemin = new ArrayList<Jalon>(Arrays.asList(jalon));

    }

    Adresse(Jalon jalon) {

      this.prop = null;

      chemin = new ArrayList<Jalon>(Arrays.asList(jalon));

    }

    int getLongueur() {

      return chemin.size();

    }

    Jalon getLastJalon() {

      return chemin.get(chemin.size()-1);

    }

    void renommer(Class<? extends Element> classe, String oldType, String newType) {

      for (Jalon jalon : chemin)

        if (jalon.classe==classe&&jalon.type.equals(oldType))

          jalon.type = newType;

    }

    boolean contient(Class<? extends Element> classe, String type) {

      for (Jalon jalon : chemin) {

        if (jalon.classe==classe&&jalon.type.equals(type)) return true;

      }

      return false;

    }

    @Override

    public String toString() {

      String nom = "";

      for (Jalon jalon : chemin) {

        nom += jalon;

      }

      nom += ": "+prop;

      return nom;

    }

  }

  public static class Jalon implements Serializable {

    public enum Origine {

      ELT_0, ELT_1, ELT_2, REL_SORTANTE, REL_ENTRANTE, SCH_CONTENANT

    }

    /**

     * L'origine d'un jalon indique d'où ce jalon provient :

     * ELT_0 est  un jalon de classe quelconque qui est toujours le premier jalon d'une adresse complète. 

     * ELT_1 et ELT_2 sont des jalons de classe quelconque qui proviennent d'un jalon précédent de classe Relation  

     * REL_S et REL_E sont des jalons de classe Relation qui proviennent d'un jalon précédent de classe quelconque

     * SCH_C est un jalon de classe Schema qui provient d'un jalon précédent de classe quelconque

     */

    public Origine origine;

    public Class<? extends Element> classe;

    public String type;

    Jalon(Origine origine, Class<? extends Element> classe, String type) {

      this.classe = classe;

      this.origine = origine;

      this.type = type;

    }

    Jalon(Jalon jalon) {

      this.classe = jalon.classe;

      this.origine = jalon.origine;

      this.type = jalon.type;

    }

    @Override

    public String toString() {

      switch (origine) {

        case SCH_CONTENANT:

          return "{"+type;

        case REL_ENTRANTE:

          return "<"+type+"<";

        case REL_SORTANTE:

          return ">"+type+">";

        case ELT_0:

          return type;

        case ELT_1:

          return type;

        case ELT_2:

          return type;

        default:

          return "ERREUR!!";

      }

    }

  }

  /** 

   * Champs de la classe Vue :

   * Données spécifiant la vue: 

   *   - typesA voir, champs, adresses, modifiables

   *   - champsId

   * (ce sont les seuls champs à sauvegarder et à recharger) 

   * Le champ unitesAVoir est un raccourci pour éviter de retrier chaque fois les données correspondantes de Corpus

   */

  private ArrayList<VueListener> listeCorrespondants = new ArrayList<VueListener>();

  private Corpus corpus;

  private boolean modifiee = false;

  ;

  // types d'éléments à voir pour chaque classe

  private HashMap<Class<? extends Element>, String[]> typesAVoir =

          new HashMap<Class<? extends Element>, String[]>();

  // champs en ordre (niveau et position) pour chaque type d'éléments à voir pour chaque classe 

  private HashMap<Class<? extends Element>, HashMap<String, String[][]>> champspos =

          new HashMap<Class<? extends Element>, HashMap<String, String[][]>>();

  // adresse pour chaque champ pour chaque  type d'élément à voir pour chaque classe

  private HashMap<Class<? extends Element>, HashMap<String, HashMap<String, Adresse>>> adresses =

          new HashMap<Class<? extends Element>, HashMap<String, HashMap<String, Adresse>>>();

  // modifiabilité pour chaque champ pour chaque  type d'élément à voir pour chaque classe

  private HashMap<Class<? extends Element>, HashMap<String, HashMap<String, Boolean>>> modifiables =

          new HashMap<Class<? extends Element>, HashMap<String, HashMap<String, Boolean>>>();

  // champ choisi comme identifiant (s'il existe) pour chaque type de chaque classe

  private HashMap<Class<? extends Element>, HashMap<String, String>> champsId =

          new HashMap<Class<? extends Element>, HashMap<String, String>>();

// style pour tout le texte

  private SimpleAttributeSet styleTexte;

  // style (s'il existe) pour chaque type de chaque classe

  private HashMap<Class<? extends Element>, HashMap<String, SimpleAttributeSet>> stylesElements =

          new HashMap<Class<? extends Element>, HashMap<String, SimpleAttributeSet>>();

  // style (s'il existe) pour chaque valeur de chaque champ de chaque type de chaque classe

  private HashMap<Class<? extends Element>, HashMap<String, HashMap<String, HashMap<String, SimpleAttributeSet>>>> stylesValeursElements =

          new HashMap<Class<? extends Element>, HashMap<String, HashMap<String, HashMap<String, SimpleAttributeSet>>>>();

  // unites par type d'unites à voir

  private HashMap<String, Unite[]> unitesAVoir = new HashMap<String, Unite[]>();

  /* Constructeur de la classe Vue */

  @SuppressWarnings("unchecked")

  public Vue(Corpus corpus) {

    this.corpus = corpus;

    corpus.addEventListener(this);

    for (Class<? extends Element> classe : new Class[]{Unite.class, Relation.class, Schema.class}) {

      typesAVoir.put(classe, new String[0]);

      champspos.put(classe, new HashMap<String, String[][]>());

      adresses.put(classe, new HashMap<String, HashMap<String, Adresse>>());

      modifiables.put(classe, new HashMap<String, HashMap<String, Boolean>>());

      champsId.put(classe, new HashMap<String, String>());

      stylesElements.put(classe, new HashMap<String, SimpleAttributeSet>());

      stylesValeursElements.put(classe, new HashMap<String, HashMap<String, HashMap<String, SimpleAttributeSet>>>());

    }

    this.styleTexte = new SimpleAttributeSet(PanneauTexte.STANDARD_DEFAUT);

  }

  public void addEventListener(VueListener correspondant) {

    listeCorrespondants.add(correspondant);

  }

  public void removeEventListener(VueListener correspondant) {

    listeCorrespondants.remove(correspondant);

  }

  private void fireMessage(Message evt) {

    for (Object corresp : listeCorrespondants.toArray()) {

      ((VueListener) corresp).traiterEvent(evt);

    }

  }

  public boolean isModifiee() {

    return modifiee;

  }

  public void ecrireJava(ObjectOutputStream oos) throws IOException {

    oos.writeObject(typesAVoir);

    oos.writeObject(champspos);

    oos.writeObject(adresses);

    oos.writeObject(modifiables);

    oos.writeObject(champsId);

    oos.writeObject(styleTexte);

    oos.writeObject(stylesElements);

    oos.writeObject(stylesValeursElements);

    modifiee = false;

  }

  @SuppressWarnings("unchecked")

  public boolean lireJava(ObjectInputStream ois) throws IOException, ClassNotFoundException, ClassCastException {

    HashMap<Class<? extends Element>, String[]> typesAVoirLus =

            (HashMap<Class<? extends Element>, String[]>) ois.readObject();

    HashMap<Class<? extends Element>, HashMap<String, String[][]>> champsposLus =

            (HashMap<Class<? extends Element>, HashMap<String, String[][]>>) ois.readObject();

    HashMap<Class<? extends Element>, HashMap<String, HashMap<String, Adresse>>> adressesLues =

            (HashMap<Class<? extends Element>, HashMap<String, HashMap<String, Adresse>>>) ois.readObject();

    HashMap<Class<? extends Element>, HashMap<String, HashMap<String, Boolean>>> modifablesLus =

            (HashMap<Class<? extends Element>, HashMap<String, HashMap<String, Boolean>>>) ois.readObject();

    HashMap<Class<? extends Element>, HashMap<String, String>> champsIdLus =

            (HashMap<Class<? extends Element>, HashMap<String, String>>) ois.readObject();

    SimpleAttributeSet styleTexteLu = (SimpleAttributeSet) ois.readObject();

    HashMap<Class<? extends Element>, HashMap<String, SimpleAttributeSet>> stylesElementsLus =

            (HashMap<Class<? extends Element>, HashMap<String, SimpleAttributeSet>>) ois.readObject();

    HashMap<Class<? extends Element>, HashMap<String, HashMap<String, HashMap<String, SimpleAttributeSet>>>> stylesValeursElementsLus =

            (HashMap<Class<? extends Element>, HashMap<String, HashMap<String, HashMap<String, SimpleAttributeSet>>>>) ois.readObject();

    for (Class<? extends Element> classe : new Class[]{Unite.class, Relation.class, Schema.class}) {

      for (String type : typesAVoirLus.get(classe)) {

        if (!corpus.getStructure().getTypes(classe).contains(type))

          return false;

      }

    }

    // En prévision d'une compatibilité ascendante

    boolean suite = false;

    try {

      suite = ois.readBoolean();

    } catch (EOFException eOFException) {

    }

    if (suite) {

      System.out.println("Il y a d'autres objets dans le .ecv");

    }

    typesAVoir = typesAVoirLus;

    champspos = champsposLus;

    adresses = adressesLues;

    modifiables = modifablesLus;

    champsId = champsIdLus;

    styleTexte = styleTexteLu;

    stylesElements = stylesElementsLus;

    stylesValeursElements = stylesValeursElementsLus;

    unitesAVoir.clear();

    modifiee = false;

    for (String type : typesAVoir.get(Unite.class)) majUnitesAVoir(type);

    fireMessage(new VueEvent(this, TypeModifVue.NEW_VUE));

    return true;

  }

  public void traiterEvent(Message evt) { // Messages de corpus

    switch (evt.getType()) {

      case CLEAR_CORPUS:

        initVueParDefaut();

        fireMessage(evt);

        return;

      case CORPUS_SAVED:

    	  fireMessage(evt);

          return;

      case NEW_CORPUS:

        initVueParDefaut();

        fireMessage(evt);

        return;

      case MODIF_TEXTE:

        fireMessage(evt);

        return;

      case MODIF_ELEMENT:

        ElementEvent evtE = (ElementEvent) evt;

        switch (evtE.getModif()) {

          case AJOUT_UNITE:

            if (!unitesAVoir.containsKey(evtE.getElement().getType())) return;

            majUnitesAVoir(evtE.getElement().getType());

            fireMessage(evt);

            return;

          case SUP_UNITE:

            if (!unitesAVoir.containsKey(evtE.getElement().getType())) return;

            majUnitesAVoir(evtE.getElement().getType());

            fireMessage(evt);

            return;

          case BORNES_UNITE:

        	  if (!unitesAVoir.containsKey(evtE.getElement().getType())) return;

              majUnitesAVoir(evtE.getElement().getType());

              fireMessage(evt);

              return;

          case AJOUT_RELATION:

          case AJOUT_SCHEMA:

          case SUP_RELATION:

          case SUP_SCHEMA:

          case MODIF_SCHEMA:

          case MODIF_VALEUR:

            fireMessage(evt);

            return;

          default:

            throw new UnsupportedOperationException("Cas "+evtE.getModif()+" oublié dans un switch");

        }

      case MODIF_STRUCTURE:

        StructureEvent evtS = (StructureEvent) evt;

        switch (evtS.getModif()) {

          case FUSION_TYPE:

            fusionnerType(evtS.getClasse(), evtS.getArg(0), evtS.getArg(1));

            fireMessage(evt);

            return;

          case RENOM_TYPE:

            renommerType(evtS.getClasse(), evtS.getArg(0), evtS.getArg(1));

            fireMessage(evt);

            return;

          case AJOUT_TYPE:

            ajouterType(evtS.getClasse(), evtS.getArg());

            fireMessage(evt);

            return;

          case AJOUT_TYPE_ET_ELEMENTS:

            ajouterType(evtS.getClasse(), evtS.getArg());

            if (evtS.getClasse()==Unite.class&&unitesAVoir.containsKey(evtS.getArg()))

              majUnitesAVoir(evtS.getArg());

            fireMessage(evt);

            return;

          case SUPPR_TYPE:

            supprimerType(evtS.getClasse(), evtS.getArg());

            fireMessage(evt);

            return;

          case AJOUT_PROP:

            ajouterProp(evtS.getClasse(), evtS.getArg(0), evtS.getArg(1));

            fireMessage(evt);

            return;

          case AJOUT_FORME_UNITE:

            ajouterFormeUnite(evtS.getArg(0));

            fireMessage(evt);

            return;

           case FUSION_PROP:

            fusionnerProp(evtS.getClasse(), evtS.getArg(0), evtS.getArg(1), evtS.getArg(2));

            fireMessage(evt);

            return;

          case RENOM_PROP:

            renommerProp(evtS.getClasse(), evtS.getArg(0), evtS.getArg(1), evtS.getArg(2));

            fireMessage(evt);

            return;

          case SUPPR_PROP:

            supprimerProp(evtS.getClasse(), evtS.getArg(0), evtS.getArg(1));

            fireMessage(evt);

            return;

          case RENOM_VALEUR:

          case FUSION_VALEUR:

          case SUPPR_VALEUR:

          case AJOUT_VALEUR:

            fireMessage(evt);

            return;

          case VALEUR_PAR_DEFAUT:

            fireMessage(evt);

            return;

          default:

            throw new UnsupportedOperationException("Cas "+evtS.getModif()+" oublié dans un switch");

        }

      default:

        throw new UnsupportedOperationException("Cas "+evt.getType()+" oublié dans un switch");

    }

  }

  @SuppressWarnings("unchecked")

  private void initVueParDefaut() {

    unitesAVoir.clear();

    for (Class<? extends Element> classe : new Class[]{Unite.class, Relation.class, Schema.class}) {

      String[] types = getTypes(classe);

      Arrays.sort(types);

      typesAVoir.put(classe, types);

      champspos.get(classe).clear();

      adresses.get(classe).clear();

      champsId.get(classe).clear();

      styleTexte = new SimpleAttributeSet(PanneauTexte.STANDARD_DEFAUT);

      stylesElements.get(classe).clear();

      stylesValeursElements.get(classe).clear();

      for (String type : typesAVoir.get(classe)) {

        Jalon jalon0 = new Jalon(Jalon.Origine.ELT_0, classe, type);

        String[] chps = getNomsProps(new Adresse(jalon0));

        champspos.get(classe).put(type, new String[1][]);

        champspos.get(classe).get(type)[0] = chps;

        adresses.get(classe).put(type, new HashMap<String, Adresse>());

        modifiables.get(classe).put(type, new HashMap<String, Boolean>());

        for (String chp : chps) {

          adresses.get(classe).get(type).put(chp, new Adresse(jalon0, chp));

          modifiables.get(classe).get(type).put(chp, true);

        }

        if (classe==Unite.class) majUnitesAVoir(type);

      }

    }

    modifiee = false;

    fireMessage(new VueEvent(this, TypeModifVue.VUE_DEFAUT));

  }

  private void majUnitesAVoir(String typeUnite) {

    Unite[] unts = corpus.getUnites(typeUnite).toArray(new Unite[0]);

    Arrays.sort(unts);

    unitesAVoir.put(typeUnite, unts);

  }

  public void retablirVueParDefaut() {

    initVueParDefaut();

  }

  public void setStyleTexte(SimpleAttributeSet att) {

    styleTexte = att;

  }

  public SimpleAttributeSet getStyleTexte() {

    return styleTexte;

  }

  public void modifierVueParSaisie(

          HashMap<Class<? extends Element>, HashMap<String, Boolean>> newIsTypesAVoir,

          HashMap<Class<? extends Element>, HashMap<String, ArrayList<Adresse>>> newAdressesAVoir,

          HashMap<Class<? extends Element>, HashMap<String, ArrayList<String>>> newChampsAVoir,

          HashMap<Class<? extends Element>, HashMap<String, String>> newChampsId,

          HashMap<Class<? extends Element>, HashMap<String, HashMap<String, Boolean>>> newModifables,

          HashMap<Class<? extends Element>, HashMap<String, HashMap<String, Integer>>> newPositionsChamps,

          HashMap<Class<? extends Element>, HashMap<String, HashMap<String, Integer>>> newNiveauxChamps,

          HashMap<Class<? extends Element>, HashMap<String, SimpleAttributeSet>> newStylesElements,

          HashMap<Class<? extends Element>, HashMap<String, HashMap<String, HashMap<String, SimpleAttributeSet>>>> newStylesValeursElements) {

    setTypesAVoir(newIsTypesAVoir);

    setChampsAdresses(newChampsAVoir, newAdressesAVoir, newPositionsChamps, newNiveauxChamps);

    setChampsModifiables(newChampsAVoir, newModifables);

    setChampsId(newChampsId);

    setStylesElements(newStylesElements);

    setStylesValeursElements(newStylesValeursElements);

    unitesAVoir.clear();

    for (String typeUnite : typesAVoir.get(Unite.class))

      majUnitesAVoir(typeUnite);

    modifiee = true;

    fireMessage(new VueEvent(this, TypeModifVue.EXTRACTION));

  }

  @SuppressWarnings("unchecked")

  private void setTypesAVoir(HashMap<Class<? extends Element>, HashMap<String, Boolean>> isAVoir) {

    for (Class<? extends Element> classe : new Class[]{Unite.class, Relation.class, Schema.class}) {

      ArrayList<String> types = new ArrayList<String>();

      for (String type : getTypes(classe)) if (isAVoir.get(classe).get(type))

          types.add(type);

      typesAVoir.put(classe, types.toArray(new String[0]));

    }

  }

  @SuppressWarnings("unchecked")

  private void setChampsAdresses(

          HashMap<Class<? extends Element>, HashMap<String, ArrayList<String>>> champsAVoir,

          HashMap<Class<? extends Element>, HashMap<String, ArrayList<Adresse>>> adressesAVoir,

          HashMap<Class<? extends Element>, HashMap<String, HashMap<String, Integer>>> positionsChamps,

          HashMap<Class<? extends Element>, HashMap<String, HashMap<String, Integer>>> niveauxChamps) {

    for (Class<? extends Element> classe : new Class[]{Unite.class, Relation.class, Schema.class}) {

      adresses.get(classe).clear();

      for (int i = 0; i<typesAVoir.get(classe).length; i++) {

        String type = typesAVoir.get(classe)[i];

        ArrayList<String> chps = champsAVoir.get(classe).get(type);

        adresses.get(classe).put(type, new HashMap<String, Adresse>());

        for (int j = 0; j<chps.size(); j++)

          adresses.get(classe).get(type).put(chps.get(j), adressesAVoir.get(classe).get(type).get(j));

        champspos.get(classe).put(type, ordonnerChamps(chps, niveauxChamps.get(classe).get(type),

                positionsChamps.get(classe).get(type)));

      }

    }

  }

  private String[][] insererChamp(String[][] chpsenordre, String newchp) {

    if (chpsenordre.length==0) {

      String[][] chps = new String[1][1];

      chps[0][0] = newchp;

      return chps;

    }

    String[] chs1 = new String[chpsenordre[0].length+1];

    chs1[0] = newchp;

    System.arraycopy(chpsenordre[0], 0, chs1, 1, chpsenordre[0].length);

    chpsenordre[0] = chs1;

    return chpsenordre;

  }

  private String[][] ordonnerChamps(ArrayList<String> chps, HashMap<String, Integer> nivx, HashMap<String, Integer> poss) {

    HashMap<Integer, HashMap<Integer, ArrayList<String>>> chpstries =

            new HashMap<Integer, HashMap<Integer, ArrayList<String>>>();

    for (String ch : chps) {

      int niv = nivx.get(ch);

      if (!chpstries.containsKey(niv))

        chpstries.put(niv, new HashMap<Integer, ArrayList<String>>());

      int pos = poss.get(ch);

      if (!chpstries.get(niv).containsKey(pos))

        chpstries.get(niv).put(pos, new ArrayList<String>());

      chpstries.get(niv).get(pos).add(ch);

    }

    Integer[] niveaux = chpstries.keySet().toArray(new Integer[0]);

    Arrays.sort(niveaux);

    String[][] chpsenordre = new String[niveaux.length][];

    int niveauenordre = 0;

    for (int niv : niveaux) {

      Integer[] positions = chpstries.get(niv).keySet().toArray(new Integer[0]);

      Arrays.sort(positions);

      int nbch = 0;

      for (int pos : positions) nbch += chpstries.get(niv).get(pos).size();

      chpsenordre[niveauenordre] = new String[nbch];

      int positionenordre = 0;

      for (int pos : positions) {

        String[] chs = chpstries.get(niv).get(pos).toArray(new String[0]);

        Arrays.sort(chs);

        for (String ch : chs)

          chpsenordre[niveauenordre][positionenordre++] = ch;

      }

      niveauenordre++;

    }

    return chpsenordre;

  }

  @SuppressWarnings("unchecked")

  private void setChampsModifiables(HashMap<Class<? extends Element>, HashMap<String, ArrayList<String>>> newChampsAVoir,

          HashMap<Class<? extends Element>, HashMap<String, HashMap<String, Boolean>>> newModifables) {

    for (Class<? extends Element> classe : new Class[]{Unite.class, Relation.class, Schema.class}) {

      modifiables.get(classe).clear();

      for (int i = 0; i<typesAVoir.get(classe).length; i++) {

        String type = typesAVoir.get(classe)[i];

        modifiables.get(classe).put(type, new HashMap<String, Boolean>());

        for (String chp : newChampsAVoir.get(classe).get(type))

          modifiables.get(classe).get(type).put(chp, newModifables.get(classe).get(type).get(chp));

      }

    }

  }

  @SuppressWarnings("unchecked")

  private void setChampsId(HashMap<Class<? extends Element>, HashMap<String, String>> newChampsId) {

    for (Class<? extends Element> classe : new Class[]{Unite.class, Relation.class, Schema.class}) {

      champsId.get(classe).clear();

      champsId.get(classe).putAll(newChampsId.get(classe));

    }

  }

  @SuppressWarnings("unchecked")

  private void setStylesElements(HashMap<Class<? extends Element>, HashMap<String, SimpleAttributeSet>> newStylesElements) {

    for (Class<? extends Element> classe : new Class[]{Unite.class, Relation.class, Schema.class}) {

      stylesElements.get(classe).clear();

      stylesElements.get(classe).putAll(newStylesElements.get(classe));

    }

  }

  @SuppressWarnings("unchecked")

  private void setStylesValeursElements(HashMap<Class<? extends Element>, HashMap<String, HashMap<String, HashMap<String, SimpleAttributeSet>>>> newStylesValeursElements) {

    for (Class<? extends Element> classe : new Class[]{Unite.class, Relation.class, Schema.class}) {

      stylesValeursElements.get(classe).clear();

      stylesValeursElements.get(classe).putAll(newStylesValeursElements.get(classe));

    }

  }

  public Corpus getCorpus() {

    return corpus;

  }

  public String[] getTypes(Class<? extends Element> classe) {

    String[] types = corpus.getStructure().getTypes(classe).toArray(new String[0]);

    Arrays.sort(types);

    return types;

  }

  @SuppressWarnings("unchecked")

  public HashMap<Class<? extends Element>, HashMap<String, Boolean>> isTypesAVoir() {

    HashMap<Class<? extends Element>, HashMap<String, Boolean>> isAVoir =

            new HashMap<Class<? extends Element>, HashMap<String, Boolean>>();

    for (Class<? extends Element> classe : new Class[]{Unite.class, Relation.class, Schema.class}) {

      isAVoir.put(classe, new HashMap<String, Boolean>());

      for (String type : getTypes(classe)) isAVoir.get(classe).put(type, false);

      for (String type : typesAVoir.get(classe))

        isAVoir.get(classe).put(type, true);

    }

    return isAVoir;

  }

  String[] getTypesAVoir(Class<? extends Element> classe) {

    return typesAVoir.get(classe);

  }

  public String[] getTypesUnitesAVoir() {

    return getTypesAVoir(Unite.class);

  }

  public String[] getTypesRelationsAVoir() {

    return getTypesAVoir(Relation.class);

  }

  public String[] getTypesSchemasAVoir() {

    return getTypesAVoir(Schema.class);

  }

  public String getChampId(Class<? extends Element> classe, String type) {

    return champsId.get(classe).get(type);

  }

  public SimpleAttributeSet getStyleElements(Class<? extends Element> classe, String type) {

    return stylesElements.get(classe).get(type);

  }

  public HashMap<String, HashMap<String, SimpleAttributeSet>> getStyleValeursElements(

          Class<? extends Element> classe, String type) {

    return stylesValeursElements.get(classe).get(type);

  }

  public String[][] getChamps(Class<? extends Element> classe, String type) {

    if (champspos.get(classe).containsKey(type)) {

      return champspos.get(classe).get(type);

    } else {

      return new String[0][];

    }

  }

  public String[] getNomsChamps(Class<? extends Element> classe, String type) {

    return getListeChamps(classe, type).toArray(new String[0]);

  }

  //la méthode suivante publique pour pouvoir l'utiliser dans une autre classe

  public ArrayList<String> getListeChamps(Class<? extends Element> classe, String type) {

    // utilisé aussi par VisuVue

    ArrayList<String> lchps = new ArrayList<String>();

    if (champspos.get(classe).containsKey(type))

      for (String[] champsniveau : champspos.get(classe).get(type))

        lchps.addAll(Arrays.asList(champsniveau));

    return lchps;

  }

  static String trouveNomChampParDefaut(Adresse ad, ArrayList<String> chps) {

    String nom;

    if (ad.chemin.size()==1) {

      nom = ad.prop;

      while (chps.contains(nom)) nom += "-0";

      return nom;

    }

    for (int i = 1; true; i++) {

      nom = ad.prop+"-"+i;

      if (!chps.contains(nom)) {

        return nom;

      }

    }

  }

  String[] getNomsProps(Adresse adresse) {

    String[] props;

    Jalon jalon = adresse.getLastJalon();

    props = corpus.getStructure().getNomsProps(jalon.classe, jalon.type).toArray(new String[0]);