Cours CNAM par J. Laforgue

Outil02_FormulaireIHM

Retour

Télécharger

Ce .zip contient des packages utilitaires utilisés dans les exemples.

Ce répertoire est composé des packages suivants :

fr.cnam.ihm qui contient les classes de Formulaire permettant de créer des IHM facilement pour la réalisation de nos programmes :

- les formulaires
- une grille de jeu
- un canvas de dessin

fr.cnam.tore qui contient les classes de déplacement dans un espace de Tore

La documentation de ces packages est accessible dans le répertoire doc/index.html

      compil.bat
      doc.bat
      faireJar.bat
      images
         cards_gif
      runTesterCanvasIHM.bat
      runTesterFormulaire.bat
      runTesterGrilleIHM.bat
      src
         fr
            cnam
               ihm
                  CanvasIHM.java

package fr.cnam.ihm;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.*;

import fr.cnam.tore.*;
import fr.cnam.ihm.*;

/**
   Classe de définition d'un canvas dans lequel on peut afficher une grille IHM avec laquelle il est possible : 
   - de colorer ou effacer une case de la grille 
   - de realiser une action si on clique dans une des cases de la grille 
   - si la grille n'est pas affichee alors on peut tracer des lignes et ecrire du texte et  
   avoir une action quand on clique dans le canvas ou quand on deplace la souris  
   - on peut dessiner des polygones (2D) qui peuvent avoir une position aussi en Z. Les polygones sont affichés en fonction de Z, avec X plus prioritaire que Y.
*/
public class CanvasIHM 
{
  private final static int    NB_MAX_MARQUE = 10;
  /*1 = Carre avec une marge 2 = Ronde avec une marge**/
  public static int TYPE_MARQUE = 1;

private JFrame              fen;
  private JPanel              _panelPP;
  private Canvas             _canvas;
  private ControlesCanvasIHM _actions;
  private int                _nbX;
  private int                _nbY;
  private int                _tailleCase;
  private int                _grille[][];
  private ArrayList<LigneCanvas>   _lignes;
  private ArrayList<TexteCanvas>   _textes;
  private ArrayList<PolygoneCanvas>   _polygones;
  private int                _xCanvas;
  private int                _yCanvas;
  private int                _width; // du canvas
  private int                _height;
  private Color[]            _couleurs;
  private boolean           _afficherGrille;

/**
     Constructeur d'un canvas d'IHM
     @param nbX nombre de case en largeur
     @param nbY nombre de case en hauteur
     @param tailleCase taille de chaque case
  **/
  public CanvasIHM(int nbX,
                   int nbY,
                   int tailleCase)
  {
    _afficherGrille = true;
    initCanvasIHM(nbX,nbY,tailleCase);
  }

/**
     Constructeur d'un canvas d'IHM
     @param width largeur du Canvas
     @param height hauteur du Canvas
  **/
  public CanvasIHM(int width,
                   int height)
  {
    _afficherGrille = false;
    initCanvasIHM(width,height,1);
  }
  
  private void initCanvasIHM(int nbX,
                                    int nbY,
                                    int tailleCase)
  {
    // Si utilisation de la methode creerCanvasIhmDansFrame
    fen=null;

// Creation du panel principal
    _panelPP = new JPanel();
    _panelPP.setLayout(null);

// Caractéristiques de l'ihm
    _tailleCase  = tailleCase;
    _nbX         = nbX;
    _nbY         = nbY;
    _xCanvas     = 5;
    _yCanvas     = 5;
    _width       = _nbX * _tailleCase+1;
    _height      = _nbY * _tailleCase+1;
    _couleurs    = new Color[NB_MAX_MARQUE];
    _couleurs[0] = Color.black;
    _couleurs[1] = Color.cyan;
    _couleurs[2] = Color.blue;
    _couleurs[3] = Color.gray;
    _couleurs[4] = Color.green;
    _couleurs[5] = Color.magenta;
    _couleurs[6] = Color.orange;
    _couleurs[7] = Color.yellow;
    _couleurs[8] = Color.red;
    _couleurs[9] = Color.white;

// Creation du canvas
    _canvas = new PaintCanvas(this);
    _canvas.resize(_width,_height);

// Initialisation du tableau de la grille
    _grille = new int[_nbX][_nbY];
    razGrille();

// Initialisation de la liste de ligne
    _lignes = new ArrayList<LigneCanvas>();
    _textes = new ArrayList<TexteCanvas>();
    _polygones = new ArrayList<PolygoneCanvas>();

// Pas d'actions par defaut
    _actions = null;

// On ajoute le canvas dans le panelPP
    // 
    _canvas.setBounds(_xCanvas,_yCanvas,_width,_height);
    _panelPP.add(_canvas);

// Action de la souris dans le canevas
    _canvas.addMouseListener( new SourisAction(this));
  }

// ======================================================================
  /**
     Initialise ou change les actions utilise dans le Canvas
     @param actions un objet qui implémente l'interface ControlesCanvasIHM
  */
  public void setActions(ControlesCanvasIHM actions)
  {
    _actions = actions;
  }
  
  // ======================================================================
  /**
     Retourne le panel prinicipal de l'IHM
     @return le panel
  */
  public JPanel getPanel()
  {
    return(_panelPP);
  }

/** Retourne la largeur du canvas de la grille
      @return largeur 
  */
  public int getWidth(){return _width;}

/** Retourne la hauteur du canvas de la grille
      @return largeur 
  */
  public int getHeight(){return _height;}

// ======================================================================
  /** Efface le contenu de la grille 
      (La valeur 0 est mise dans chaque case)
  */
  public void razGrille()
  {
    for(int i=0;i<_nbX;i++)
      {
        for(int j=0;j<_nbY;j++)
          {
            _grille[i][j]=0;
          }
      }
  }

// ======================================================================
  /** Affecte à une case de la grille la marque (couleur)
      @param marque une valeur de 1 à 10 (couleur) ou 0 (case vide)
      @param x coordonnée en x de la case
      @param y coordonnée en y de la case
  */
  public void setMarque(int marque,int x,int y)
  {
    _grille[x][y] = marque;
    marquer(marque,x,y);
  }

// ======================================================================
  /** Ajout d'une ligne de (x1,y1) a (x2,y2) et de couleur.
      @param couleur (valeur de 1 à 10)
      @param x1 coord en X du 1er point
      @param y1 coord en Y du 1er point
      @param x2 coord en X du 2eme point
      @param y2 coors en Y du 2eme point
  */
  public void ajouterLigne(int couleur,int x1,int y1,int x2,int y2)
  {
    _lignes.add(new LigneCanvas(couleur,x1,y1,x2,y2));
    dessinerLignes();
  }

// ======================================================================
  /** Ajout d'un texte dans le canvas a une position (x,y)
      @param texte La valeur de la chaine
      @param x coord en X du texte
      @param y coord en Y du texte
      @param couleur (valeur de 1 à 10)
  */
  public void ajouterTexte(String texte,int x,int y,int couleur)
  {
    _textes.add(new TexteCanvas(texte,x,y,couleur));
    dessinerTextes();
  }

// ======================================================================
  /** Ajout d'un polygone p1,p2,....  et de couleur.
      @param objet objet quelconque (utilisé dans pointerCanvas)
      @param position position de l'objet en (x,y,z)
      @param couleur couleur (valeur de 1 à 10)
      @param points les points du polygone
  */
  public void ajouterPolygone(Object objet,Position position,int couleur,Point... points)
  {
    _polygones.add(new PolygoneCanvas(objet,position,couleur,points));
    dessinerPolygones();
  }

// ======================================================================
  /** Ajout d'un polygone p1,p2,....  et de couleur.
      @param rc ressources graphiques d'affichage
      @param o objet quelconque (utilisé dans pointerCanvas)
      @param p position de l'objet en (x,y,z)
      @param points les points du polygone
  */
  public void ajouterPolygone(RessourcesCanvas rc,Object o,Position p,Point... points)
  {
    _polygones.add(new PolygoneCanvas(rc,o,p,points));
    dessinerPolygones();
  }

// ======================================================================
  /** Retourne la marque de la case
      @param x coordonnée en x de la case
      @param y coordonnée en y de la case
      @return la valeur de la case (de 0 à 10)
  */
  public int getMarque(int x,int y)
  {
    return(_grille[x][y]);
  }
  
  // ======================================================================
  /** Teste si la case est libre (différente de 0)
      @param x coordonnée en x de la case
      @param y coordonnée en y de la case
      @return true si la case est libre sinon false
  */
  public boolean siCaseLibre(int x,int y)
  {
    return( getMarque(x,y)==0 );
  }
  
  // ======================================================================
  /** Retourne le nombre de colonne de la grille
      @return le nombre de colonne
  */
  public int getNbX()
  {
    return(_nbX);
  }
  
  // ======================================================================
  /** Retourne le nombre de ligne de la grille
      @return le nombre de ligne
  */
  public int getNbY()
  {
    return(_nbY);
  }

// ======================================================================
  /** Retourne le nombre max de couleur 
      @return nombre max
  */
  public int getNbMaxMarqueur()
  {
    return(NB_MAX_MARQUE);
  }

// ======================================================================
  /** Desaffichage de la grille du canvas
   */
  public void desafficherGrille()
  {
    Graphics g = _canvas.getGraphics();
    _afficherGrille=false;
    // On efface toute la grille
    g.clearRect(0,0,_width+1,_height+1);
  }

// ======================================================================
  /** Affichage de la grille dans le canvas
   */
  public void afficherGrille()
  {
    _afficherGrille=true;
    dessinerGrille();
  }

// ======================================================================
  /** Methode static qui permet de creer le canvas inclus dans un Frame
      @param nbX nombre de colonnes de la grille
      @param nbY nombre de lignes de la grille
      @param tailleCase taille de chaque case en pixel
      @return retourne le canvas créé
  */
  static public CanvasIHM creerCanvasIhmDansFrame(int nbX,
                                                  int nbY,
                                                  int tailleCase
                                                  )
  {
    // On crée la fenêtre
    JFrame fen = new JFrame();

// On y ajoute la grille
    CanvasIHM ihm = new CanvasIHM(nbX,nbY,tailleCase);
    ihm.fen = fen;

// Panel in Frame
    fen.add(ihm.getPanel());

// Pour fermer la fenetre
    GrilleWindowAdapter a = new GrilleWindowAdapter();
    fen.addWindowListener((WindowListener)a);
        
    return(ihm);
  }

// Affiche la fenetre
  public void afficherFrame(int posX,int posY)
  {
    fen.setLocation(posX,posY);
    fen.setPreferredSize(new Dimension(_width+20,_height+20));
    fen.pack();
    fen.show();
  }

public JFrame getFrame()
  {
    return fen;
  }

/* Retourne les lignes du canvas
     @return ArrayList<LigneCanvas>
  */
  public ArrayList<LigneCanvas> getLignes()
  {
    return _lignes;
  }

/* Retourne les textes du canvas
     @return ArrayList<TexteCanvas>
  */
  public ArrayList<TexteCanvas> getTextes()
  {
    return _textes;
  }

/* Retourne les polygones du canvas
     @return ArrayList<PolygoneCanvas>
  */
  public ArrayList<PolygoneCanvas> getPolygones()
  {
    return _polygones;
  }

// **************************** METHODES PRIVEES ************************
    
  // Code pour dessiner la grille et colorer les cases de la grille
  //
  private void dessinerGrille()
  {
    Graphics g = _canvas.getGraphics();

if (g==null)
      {
        System.out.println("Le graphic est null. Les instrucitons de dessin doivent se faire après l'affichage du formulaire qui contient le canvas.");
        return;
      }

// On efface toute la grille
    g.clearRect(0,0,_width+1,_height+1);

// Tracer des lignes verticales
    for(int i=0;i<_nbX+1;i++)
      {
        Point p1= new Point( (_width/_nbX)*i,0);
        Point p2= new Point( (_width/_nbX)*i,_height);
        g.drawLine(p1.x,p1.y,p2.x,p2.y);
      }

// Tracer des lignes horizontales
    for(int i=0;i<_nbY+1;i++)
      {
        Point p1= new Point( 0,      (_height/_nbY)*i);
        Point p2= new Point( _width, (_height/_nbY)*i);
        g.drawLine(p1.x,p1.y,p2.x,p2.y);
      }

// Tracer des éléments
    for(int i=0;i<_nbX;i++)
      {
        for(int j=0;j<_nbY;j++)
          {
            marquer(_grille[i][j],i,j);
          }
      }
  }

// Dessine touts les lignes
  //
  private void dessinerLignes()
  {
    Graphics g = _canvas.getGraphics();

for(int i=0;i<_lignes.size();i++)
      {
        LigneCanvas l=_lignes.get(i);
        if (l.rc==null)
          g.setColor(_couleurs[l.marque-1]);
        else
          g.setColor(l.rc.getForeground());
        g.drawLine(l.p1.x,l.p1.y,l.p2.x,l.p2.y);
      }
  }

// Dessine tous les polygones
  //
  private void dessinerPolygones()
  {
    Graphics g = _canvas.getGraphics();
        
    Collections.sort(_polygones);

for(int k=0;k<_polygones.size();k++)
      {
        PolygoneCanvas p = _polygones.get(k);
        if (p.rc==null)
          g.setColor(_couleurs[p.marque-1]);
        else
          g.setColor(p.rc.getBackground());
        int[] xPoints=new int[p.points.length];
        int[] yPoints=new int[p.points.length];
        int i=0;
        for(Point pt : p.points)
          {
            xPoints[i]=pt.x;
            yPoints[i]=pt.y;
            i++;
          }
        g.fillPolygon(xPoints,yPoints,p.points.length);
        if (p.rc==null)
          g.setColor(_couleurs[0]);
        else
          g.setColor(p.rc.getForeground());
        Point cour=p.points[0];
        for(int r=1;r<p.points.length;r++)
          {
            g.drawLine(cour.x,cour.y,p.points[r].x,p.points[r].y);
            cour = p.points[r];
          }
        g.drawLine(p.points[p.points.length-1].x,p.points[p.points.length-1].y,
                   p.points[0].x,p.points[0].y);
      }
  }

// Dessine tous les textes
  //
  private void dessinerTextes()
  {
    Graphics g = _canvas.getGraphics();

for(TexteCanvas t:_textes)
      {
        if (t.rc==null)
          g.setColor(_couleurs[t.couleur-1]);
        else
          g.setColor(t.rc.getForeground());
        g.drawString(t.texte,t.p.x,t.p.y);
      }
  }

/* Effacer tout le canvas
  **/
  public void effacerCanvas()
  {
    _lignes.clear();
    _textes.clear();
    _polygones.clear();

Graphics g = _canvas.getGraphics();

// On efface toute la zone
    g.clearRect(0,0,_width+1,_height+1);
        
  }

// dessiner le contenu d'une case de la grille
  //
  private void marquer(int marque,int x,int y)
  {
    Graphics g = _canvas.getGraphics();
    int niX1 = x*(_width/_nbX);
    int niX2 = (x+1)*(_width/_nbX);
    int niY1 = y*(_height/_nbY);
    int niY2 = (y+1)*(_height/_nbY);

g.clearRect(niX1+1,niY1+1,niX2-niX1-2,niY2-niY1-2);
    if (marque >0)
      {
        g.setColor(_couleurs[marque-1]);
        if (TYPE_MARQUE==1)
          g.fillRect(niX1+2,niY1+2,niX2-niX1-4,niY2-niY1-4);
        else
          g.fillOval(niX1+2,niY1+2,niX2-niX1-4,niY2-niY1-4);
      }
  }

// determine les corrdonees de la case en fonction du point de la souris
  //
  private Point pointToCase(Point p)
  {
    int px = p.x;
    int py = p.y;

int x = px/_tailleCase;
    int y = py/_tailleCase;

if ( (x<0) || (x>=_nbX) ||
         (y<0) || (y>=_nbY) )
      return(null);
    else
      return( new Point(x,y));
  }

// determine l'objet cible du polygone en fonction du point de la souris
  //
  private Object pointToPolygone(Point p)
  {
    int px = p.x;
    int py = p.y;

for(int i=_polygones.size()-1;i>=0;i--)
      {
        if (_polygones.get(i).polygone.contains(p))
          return(_polygones.get(i).object);
      }
    return null;
  }

//********************   CLASSES INTERNES ************************

// Classe interne de definition de la surcharge de paint du canvas
  //
  class PaintCanvas extends Canvas
  {
    CanvasIHM _g;
        
    public PaintCanvas(CanvasIHM g)
    {
      _g = g;
    }

public void paint(Graphics g)
    {
      if (_afficherGrille)
        _g.dessinerGrille();
      _g.dessinerLignes();
      _g.dessinerTextes();
      _g.dessinerPolygones();
    }
  }

// Classe interne de definition de la surcharge de la souris
  //
  class SourisAction extends MouseAdapter
  {
    CanvasIHM _ihm;

public SourisAction(CanvasIHM ihm)
    {
      _ihm=ihm;
    }
    public void mouseClicked(MouseEvent e)
    {
      if (_afficherGrille)
        {
          // On détermine la case sélectionnée
          Point p = pointToCase(e.getPoint());
          if  ( (p!=null) && (_actions!=null) )
            {
              _actions.pointerCaseGrille((int)p.x,(int)p.y,_ihm);
            }
        }
      else
        {
          Point p = e.getPoint();
          if (_actions!=null)
            {
              Object obj =  pointToPolygone(e.getPoint());
              _actions.pointerCanvas(obj,(int)p.x,(int)p.y,_ihm);
                            
            }
        }
    }

}

} // Fin de CanvasIHM

// ===============================================================
// Classe privee de fermeture de la fenetre
// ===============================================================
// L'adaptateur d'une window
//
class GrilleWindowAdapter extends WindowAdapter
{
  // On ne s'interesse que a l'action de fermeture de
  // la fenetre
  public void windowClosing(WindowEvent e) 
  {
    System.exit(0);
  }
}

ControlesCanvasIHM.java

package fr.cnam.ihm;

/**
   Interface utilisée par le constructeur de CanvasHM permettant de traiter les clics dans la grille et dans le canvas
 */
public interface ControlesCanvasIHM
{
    /** 
        Methode appellee quand la grille est affichee et quand on clique dans une des cases de la grille
        @param xCase coordonnee en X de la case dans la grille
        @param yCase coordonnee en Y de la case dans la grille
        @param ihm l'instance de la CanvasIHM. Permet d'utiliser les méthodes publiques de CanvasIHM dans l'action.
    */
    public void pointerCaseGrille(int xCase,int yCase,CanvasIHM ihm);

/**
       Methode appellee quand la grille n'est pas affichee et quand on clique dans le canvas.
       @param target objet associe a l'objet geometrique
       @param x coordonnee en pixel X de la position de la souris
       @param y coordonnee en pixel Y de la position de la souris
       @param ihm l'instance de la CanvasIHM. Permet d'utiliser les méthodes publiques de CanvasIHM dans l'action.
    */
    public void pointerCanvas(Object target,int x,int y,CanvasIHM ihm);
    
}

Formulaire.java

package fr.cnam.ihm;

import java.lang.*;
import java.awt.*;
import java.awt.geom.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.text.*;
import java.util.*;
import java.io.*;

/**
   Classe de définition d'un formulaire JAVA permettant de faire à 
   minima une IHM Java pour saisir des informations et faire des 
   actions via des boutons. 
   Pour cela, il faut que l'applicatif implémente les méthodes de 
   l'interface FormulaireInt. 
*/
public class Formulaire
{
  private FormulaireInt             app;
  private JFrame                    frame;
  private int                       widthFrame;
  private int                       heightFrame;
  private JPanel                    panelPP;
  private ArrayList<JButton>        buttons;
  private String                    buttonFermer;
  private Exception                 exceptionForm;
  private int                       xCour;
  private int                       yCour;
  private int                       widthLabelCour;
  private int                       widthGapCour;
  private int                       widthTextCour;
  private int                       widthButtonCour;
  private boolean                   sensHorizontal;
  private boolean                   sensVertical;
  private String                    font;     
  private boolean                   autoWidth;

private int tailleFonte  = 11;
  private int heightText   = 20;

// Les éléments IHM du formulaire
  private Hashtable<String,JComponent>  elements;
    
  /**
     Constructeur d'un formulaire. 
     @param titre Titre affiché dans le bandeau de la fenetre
     @param app Un objet dont la classe implémente l'interface FormualaireInt
     @param width longueur du formulaire
     @param height hauteur du formulaire
  */
  public Formulaire(String titre, 
                    FormulaireInt app,
                    int width,
                    int height)
  {
    initFormulaire(titre,app,width,height,true);
  }

/**
     Constructeur d'un formulaire. 
     @param titre Titre affiché dans le bandeau de la fenetre
     @param app Un objet dont la classe implémente l'interface FormualaireInt
     @param width longueur du formulaire
     @param height hauteur du formulaire
     @param avecFrame si false alors pas de frame cree : que le panel. Ceci permet d'incruster un formulaire dans une IHM existante (un autre formulaire)
  */
  public Formulaire(String titre, 
                    FormulaireInt app,
                    int width,
                    int height,
                    boolean avecFrame)
  {
    initFormulaire(titre,app,width,height,avecFrame);
  }

private void initFormulaire(String titre, 
                              FormulaireInt app,
                              int width,
                              int height,
                              boolean avecFrame)
  {
    this.app             = app;
    if (avecFrame)
      {
        this.frame           = new JFrame(titre);
        this.widthFrame      = width;
        this.heightFrame     = height;
      }
    else
      this.frame       = null;
    this.buttonFermer    = "";
    this.font            = "Courier";
        
    this.panelPP     = new JPanel();
    this.panelPP.setLayout(null);

if (this.frame != null)
      {
        this.frame.add(panelPP);
        this.frame.addWindowListener(new FormulaireWindowListener());
      }

this.xCour               = 0;
    this.yCour               = 0;
    this.widthLabelCour      = 100;
    this.widthGapCour        = 0;
    this.widthTextCour       = 100;
    this.widthButtonCour     = 100;
    this.sensVertical        = true;
    this.sensHorizontal      = false;
    this.autoWidth           = true;

this.elements = new Hashtable<String,JComponent>();
  }

/** Initialise l'applicatif. Cette méthode est utilisée dans le cas où quand on crée le formulaire on ne connait pas encore l'applicatif qui gère le formulaire. On appelle alors cette méthode pour initialiser l'applicatif du formulaire.
      @param app Un objet qui implémente l'interface Formulaireint */
  public void setApp(FormulaireInt app)
  {
    this.app = app;
  }

/**
     Retourne le panel principal du formulaire
     @return panel principal du formulaire
  */
  public JPanel getPanel()
  {
    return this.panelPP;
  }

/** Retourne la position courante en X de la position des éléments
      @return int la valeur X */
  public int getXCour(){return xCour;}

/** Retourne la position courante en Y de la position des éléments
      @return int la valeur Y */
  public int getYCour(){return yCour;}

/** Change la position courante 
      @param x position en abscisse (horizontal) de la fenetre 
      @param y position en ordonnée (vertical) de la fenetre 
  */
  public void setPosition(int x,int y){xCour=x;yCour=y;}

/** Change la position courante par delta
      @param deltax position en abscisse (horizontal) de la fenetre 
      @param deltay position en ordonnée (vertical) de la fenetre 
  */
  public void addPosition(int deltax,int deltay)
  {
    xCour=xCour+deltax;
    yCour=yCour+deltay;
  }

/** Change la taille de la fonte courante d'un text ou d'un lable ou d'un bouton
      @param taille (int) taille de la fonte (8, 9, 10, 11, ....)
  */
  public void setTailleFonte(int taille){
    this.tailleFonte = taille;
  }

/** Change la hauteur courante d'un text ou d'un label ou bouton
      @param height (int) hauteur en pixel
   */
  public void setHeightText(int height){
    this.heightText=height;
  }

/** Change la position courante en passant a la ligne suivante en position posx
      @param posx nouvelle position courante en x */
  public void dessous(int posx)
  {
    this.xCour = posx;
    this.yCour = this.yCour+this.heightText+3;
  }

/** change le sens en HORIZONTAL */
  public void horizontal()
  {
    this.sensHorizontal=true;
    this.sensVertical=false;
  }

/** change le sens en VERTICAL */
  public void vertical()
  {
    this.sensHorizontal=false;
    this.sensVertical=true;
  }

/** Le contour des textes de Label Text et Button sont autoamtiquement ou pas ajuster a la taille du texte
      @param auto boolean
  */
  public void setAutoWidth(boolean auto){autoWidth=auto;}

/** Change la largeur courante des label
      @param width nouvelle largeur courante
  */
  public void setWidthLabelCour(int width){widthLabelCour=width;}

/** Change la largeur courante des textes de saisi
      @param width nouvelle largeur courante
  */
  public void setWidthTextCour(int width){widthTextCour=width;}

/** Change la largeur courante de séparation entre le label et le texte des champs de saisi
      @param width nouvelle largeur courante
  */
  public void setWidthGapCour(int width){widthGapCour=width;}

/** Change la largeur courante des boutons
      @param width nouvelle largeur courante
  */
  public void setWidthButtonCour(int width){widthButtonCour=width;}

/** Affichage du formulaire. 
  */
  public void afficher()
  {
    this.frame.setPreferredSize(new Dimension(this.widthFrame+15,this.heightFrame+40));
    this.frame.pack();
    this.frame.show();
  }

/** Affichage du formulaire en x,y de l'ecran
      @param x position en X du formulaire
      @param y position en Y du formulaire
  */
  public void afficher(int x,int y)
  {
    this.frame.setLocation(x,y);
    afficher();
  }

/** Permet de fermer le formulaire
   */
  public void fermer()
  {
    frame.dispose();
  }

/** Ajout d'un label dans le formulairel. 
      @param label Valeur du label
  */
  public void addLabel(String label)
  {
    int xChamp=this.xCour;
    int yChamp=this.yCour;
    int widthLabel=this.widthLabelCour;

JLabel l = new JLabel(label);

JPanel p = new JPanel();
    p.setLayout(null);
    Font f = new Font(font,Font.BOLD,tailleFonte);
    l.setFont(f);

if (autoWidth) widthLabel = l.getFontMetrics(f).stringWidth(label);

l.setBounds(0,0,widthLabel,this.heightText);

p.add(l);

p.setBounds(xChamp,yChamp,widthLabel,this.heightText);

this.panelPP.add(p);
    this.panelPP.repaint();
    if (this.frame!=null)
      this.frame.repaint();
    
    if (sensHorizontal) 
        this.xCour=this.xCour+this.widthLabelCour;
      if (sensVertical)
        this.yCour=yChamp+this.heightText+3;
  }

/** Ajout dans le formulaire un texte de saisie composé d'un label 
      et d'une zone de saisie. 
      @param nom Le nom du champ
      @param label Chaine qui précéde la zone de saisie
      @param editable détermine si la zone de saisie est éditable 
      @param value valeur initiale dans la zone de saisie
  */
  public void addText(String nom,
                      String label,
                      boolean editable,
                      String value)
  {
    int xChamp=this.xCour;
    int yChamp=this.yCour;
    int widthLabel=this.widthLabelCour;
    int widthGap=this.widthGapCour;
    int widthText=this.widthTextCour;

JLabel l = new JLabel(label);
    JTextField tf = new JTextField();
    tf.setEditable(editable);
    tf.setText(value);
    elements.put(nom,tf);

JPanel p = new JPanel();
    p.setLayout(null);
    Font f = new Font(font,Font.BOLD,tailleFonte);
    l.setFont(f);
    tf.setFont(f);

if (autoWidth) widthLabel = l.getFontMetrics(f).stringWidth(label)+3;

l.setBounds(0,0,widthLabel,this.heightText);
    tf.setBounds(widthLabel+widthGap,0,widthText,this.heightText);

p.add(l);
    p.add(tf);

p.setBounds(xChamp,yChamp,widthLabel+widthGap+widthText,this.heightText);

this.panelPP.add(p);
    this.panelPP.repaint();
    if (this.frame!=null) this.frame.repaint();
    
    if (this.sensHorizontal)
        this.xCour=xChamp+widthLabel+widthGap+widthText+3;
      if (this.sensVertical)
        this.yCour=yChamp+this.heightText+3;
  }

/** Ajout dans le formulaire d'une liste de choix de saisie composé d'un label 
      et d'une liste de choix. 
      @param nom Le nom du champ
      @param label Chaine qui précéde la zone de saisie
      @param liste tableau de la liste de choix
      @param action si vrai alors l'action est réalisée dès que l'on clique
      @param valinit valeur inital sélectionnée
  */
  public void addListeChoix(String nom,
                            String label,
                            String[] liste,
                            boolean action,
                            String valinit)
  {
    int xChamp=this.xCour;
    int yChamp=this.yCour;
    int widthLabel=this.widthLabelCour;
    int widthGap=this.widthGapCour;
    int widthText=this.widthTextCour;

JLabel l = new JLabel(label);
    JComboBox<String> cb = new JComboBox<String>();
    for(String s:liste)cb.addItem(s);
    elements.put(nom,cb);

for(int i=0;i<cb.getItemCount();i++)
      if(cb.getItemAt(i).equals(valinit))
        cb.setSelectedIndex(i);

if(action)cb.addActionListener(new SubmitListener(this,nom));

JPanel p = new JPanel();
    p.setLayout(null);
    Font f = new Font(font,Font.BOLD,tailleFonte);
    l.setFont(f);
    cb.setFont(f);

if (autoWidth) widthLabel = l.getFontMetrics(f).stringWidth(label)+3;

l.setBounds(0,0,widthLabel,this.heightText);
    cb.setBounds(widthLabel+widthGap,0,widthText,this.heightText);

p.add(l);
    p.add(cb);

p.setBounds(xChamp,yChamp,widthLabel+widthGap+widthText,this.heightText);

/** Ajout dans le formulaire d'un texte de saisie multi-ligne composé d'un label 
      et d'une zone de saisie. 
      @param nom Le nom du champ
      @param label Chaine qui précéde la zone de saisie
      @param editable détermine si la zone de saisie est éditable 
      @param value valeur initiale dans la zone de saisie 
      @param width longueur de la zone de texte
      @param height hauteur de la zone de texte
  */
  public void addZoneText(String nom,
                          String label,
                          boolean editable,
                          String value,
                          int width,
                          int height)
  {
    int xChamp=this.xCour;
    int yChamp=this.yCour;

if (this.sensHorizontal)
      this.xCour=xChamp + width+3;
    if (this.sensVertical)
      this.yCour=yChamp+height+3;
        
    JLabel l = new JLabel(label);
    l.setFont(new Font(font,Font.BOLD,tailleFonte));
    l.setBounds(0,0,width,this.heightText);

JTextArea tf = new JTextArea();
    tf.setEditable(editable);
    tf.setText(value);
    tf.setFont(new Font(font,Font.BOLD,tailleFonte));

elements.put(nom,tf);

JScrollPane scrollbar = new JScrollPane(tf);
    scrollbar.setBounds(0,0+this.heightText+3,width,height-this.heightText-3);
    scrollbar.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS); 
    scrollbar.setPreferredSize(new Dimension(width,height-this.heightText-3));

JPanel p = new JPanel();
    p.setLayout(null);

p.add(l);
    p.add(scrollbar);
        
    p.setBounds(xChamp,yChamp,width,height);

this.panelPP.add(p);
    this.panelPP.repaint();
    if (this.frame!=null) this.frame.repaint();
  }
    
  /** Ajout dans le formulaire d'une liste scrollable de valeurs. 
      @param nom Le nom de la liste scrollable
      @param titre Titre qui précéde la liste
      @param editable détermine si la zone de saisie est éditable 
      @param values valeur initiale dans la zone de saisie 
      @param width longueur de la zone (ou -1)
      @param height hauteur de la zone 
  */
  public void addListScroll(String nom,
                            String titre,
                            boolean editable,
                            String[] values,
                            int width,
                            int height)
  {
    int xChamp=this.xCour;
    int yChamp=this.yCour;

if (this.sensHorizontal)
      this.xCour=xChamp + width+3;
    if (this.sensVertical)
      this.yCour=yChamp+height+3;
        
    JLabel titrel = new JLabel(titre);
    titrel.setFont(new Font(font,Font.BOLD,tailleFonte));
    titrel.setBounds(0,0,width,this.heightText);

JList liste = new JList(new DefaultListModel());
    liste.setFont(new Font(font,Font.BOLD,tailleFonte));
    JScrollPane scroll = new JScrollPane(liste);
    scroll.setBounds(0,0+this.heightText+3,width,height-this.heightText-3);

liste.setEnabled(editable);
    Vector<String> v = new Vector<String>();
    if (values!=null)
      Collections.addAll(v,values);

elements.put(nom,liste);

JPanel p = new JPanel(new BorderLayout());
    p.add(titrel,BorderLayout.NORTH);
    p.add(scroll,BorderLayout.CENTER);

p.setBounds(xChamp,yChamp,width,height);

liste.setListData(v);

this.panelPP.add(p);
    this.panelPP.repaint();
    if (this.frame!=null)this.frame.repaint();
  }

/** Ajout d'une image
      @param nom le nom de l'image (nom de l'action si clique dans l'image)
      @param x position en x de l'image
      @param y position en y de l'image
      @param width taille en longueur de l'image
      @param height taille eh hauteur de l'image
      @param pathImage path du fichier de l'image (.jpg, .gif, .bmp, ....)
      @param cursorMove si True alors le pointeur souris se change en une main lors du survol de la souris sur l'image
      @return JLabel le label créé contenant l'image
      La valeur de retour de type JLabel permet de changer l'image en appelant la méthode setImage.
   */
  public JLabel addImage(String nom,int x,int y,int width,int height,String pathImage,boolean cursorMove)
  {
    JLabel label = new JLabel();
    label.setBounds(x,y,width,height);
    ImageIcon path = new ImageIcon(pathImage);
    Image img = path.getImage();
    Image newImg = img.getScaledInstance(width,height, Image.SCALE_SMOOTH);
    ImageIcon image = new ImageIcon(newImg);
    label.setIcon(image);

this.panelPP.add(label);

label.addMouseListener(new SubmitListener(this,nom));
    
    if (cursorMove) label.setCursor(new Cursor(Cursor.HAND_CURSOR));

return label;
  }

/** Changer l'image d'un JLabel
      @param label le JLabel dont on veut changerl'image
      @param pathImage path de l'image
   */
  public void setImage(JLabel label,String pathImage)
  {
    Rectangle r = label.getBounds(null);
    ImageIcon path = new ImageIcon(pathImage);
    Image img = path.getImage();
    Image newImg = img.getScaledInstance((int)(r.getWidth()),(int)(r.getHeight()), Image.SCALE_SMOOTH);
    ImageIcon image = new ImageIcon(newImg);
    label.setIcon(image);
  }
    
  /** Designe le bouton qui ferme la fenetre
      @param nomButton le nom du bouton
  */
  public void setButtonFermer(String nomButton)
  {
    this.buttonFermer = nomButton;
  }

/** Ajout dans le formulaire d'un bouton. 
      @param nom Le nom du bouton
      @param button Texte du bouton 
  */
  public void addButton(String nom,
                        String button)
  {
    int xChamp=this.xCour;
    int yChamp=this.yCour;
    int width =this.widthButtonCour;
        
    JButton b = new JButton(button);
    Font f = new Font(font,Font.BOLD,tailleFonte);
    b.setFont(f);
    elements.put(nom,b);
    b.setMargin(new Insets(0, 0, 0, 0));
    if (autoWidth) width = b.getFontMetrics(f).stringWidth(button)+20;

b.setBounds(xChamp,yChamp,width,this.heightText);

b.setPreferredSize(new Dimension(width,this.heightText));
    b.addActionListener(new SubmitListener(this,nom));

this.panelPP.add(b);
    this.panelPP.repaint();
    if (this.frame!=null)this.frame.repaint();
    
    if (this.sensHorizontal)
        this.xCour=xChamp+width+3;
      if (this.sensVertical)
        this.yCour=yChamp+this.heightText+3;

}

/** Ajout d'un Panel dans le formulaire
      @param panel le panel a ajouter
      @param width largeur du panel
      @param height hauteur du panel
  */
  public void addPanel(JPanel panel,int width, int height)
  {
    int posx = this.xCour;
    int posy = this.yCour;

if (this.sensHorizontal)
      this.xCour=posx+width+3;
    if (this.sensVertical)
      this.yCour=posy+height+3;

panel.setBounds(posx,posy,width,height);
    this.panelPP.add(panel);
    this.panelPP.repaint();
    if (this.frame!=null)this.frame.repaint();
  }

/** Methode qui ajoute un canvas de grille
      @param nbLigne nombre de ligne de la grille
      @param nbColonne nombre de colonne de la grille
      @param tailleCase taille de la case (en pixel)
      @param controle objet dont la classe surcharge les méthodes de l'interface ControlesCanvasIHM. Il permet de réaliser les actions réalisées dans la grille.
      @return retourne la grille d'IHM
  */
  public CanvasIHM addGrilleIHM(int nbLigne,
                                int nbColonne,
                                int tailleCase,
                                ControlesCanvasIHM controle)
  {
    CanvasIHM grille;
        
    grille = new CanvasIHM(nbLigne,nbColonne,tailleCase);
    grille.setActions(controle);
    addPanel(grille.getPanel(),
             grille.getWidth()+30,grille.getHeight()+30);
        
    return(grille);
  }

/** Methode qui ajoute un canvas de grille
      @param width largeur du canvas
      @param height hauteur du canvas
      @param controle objet dont la classe surcharge les méthodes de l'interface ControlesCanvasIHM. Il permet de réaliser les actions réalisées dans la grille.
      @return retourne la grille d'IHM
  */
  public CanvasIHM addCanvasIHM(int width,
                                int height,
                                ControlesCanvasIHM controle)
  {
    CanvasIHM grille;
        
    grille = new CanvasIHM(width,height);
    grille.getPanel().setBackground(Color.yellow);
    grille.setActions(controle);
    addPanel(grille.getPanel(),
             grille.getWidth()+30,grille.getHeight()+30);

return(grille);
  }

/** Méthode qui retourne la valeur d'un champ.
      @param nom Le nom du champ
      @return valeur la nouvelle valeur du champ */
  public String getValeurChamp(String nom)
  {
    String ret="";
    JComponent comp = elements.get(nom);
            
    try{
      if ( comp instanceof JList )
        {
          JList l = (JList)comp;
          if (! l.isSelectionEmpty())
            ret = (String)(l.getSelectedValue());
        }
      if (comp instanceof JComboBox )
        {
          JComboBox cb = (JComboBox)comp;
          ret=(String)(cb.getSelectedItem());
        }
      else
        {
          JTextComponent ct = (JTextComponent)comp;
          ret=ct.getText();
        }
    }catch(Exception ex){}
    return ret;
  }

/** Méthode qui change la valeur d'un champ.
      @param nom Le nom du champ
      @param valeur la nouvelle valeur du champ */
  public void setValeurChamp(String nom,String valeur)
  {
    JComponent comp = elements.get(nom);
    try{
      JTextComponent ct = (JTextComponent)comp;
      ct.setText(valeur);
    }catch(Exception ex){}
    try{
      JComboBox cb = (JComboBox)comp;
      for(int i=0;i<cb.getItemCount();i++)
        if(cb.getItemAt(i).equals(valeur))
          cb.setSelectedIndex(i);
    }catch(Exception ex){}
  }

/** Méthode qui change les valeurs d'une liste de scroll
      @param nom Le nom du champ
      @param values la nouvelle liste de valeur */
  public void setListData(String nom,String[] values)
  {
    try{
      JComponent comp = elements.get(nom);
      JList l = (JList)comp;
      Vector<String> v = new Vector<String>();
      if (values!=null)
        Collections.addAll(v,values);
      l.setListData(v);
    }catch(Exception ex){}
  }

// Classe d'action des boutons du formulaire
  class SubmitListener extends MouseAdapter implements ActionListener
  {
    private Formulaire form;
    private String     nomSubmit;

public SubmitListener(Formulaire form, String nomSubmit)
    {
      this.form      = form;
      this.nomSubmit = nomSubmit;
    }

public void actionPerformed(ActionEvent e)
    {
      try{
        if (app!=null)   // NE PAS UTILISER this.app : on est dans une inner class
          app.submit(form,nomSubmit);
                
        if (this.nomSubmit.equals( buttonFermer))
          {
            frame.dispose();
          }
      }
      catch(Exception ex)
        {
          ex.printStackTrace();
        }
    }

public void mouseClicked(MouseEvent e)
    {
      try{
        if (app!=null)   // NE PAS UTILISER this.app : on est dans une inner class
          app.submit(form,nomSubmit);
        
        if (this.nomSubmit.equals( buttonFermer))
          {
            frame.dispose();
          }
      }
      catch(Exception ex)
        {
          ex.printStackTrace();
        }
    }
  }
  
  // Classe pour fermer le formulaire
  class FormulaireWindowListener extends WindowAdapter
  {
    public void windowClosing(WindowEvent e)
    {
      frame.dispose();
    }
  }

/**
     desactiver un des composants du formulaire
     @param nom Nom du composant
  */
  public void desactiver(String nom) throws RuntimeException
  {
    JComponent e = elements.get(nom);
    if (e!=null)
      {
        if (e.getClass().getName().equals("javax.swing.JButton"))
          e.setEnabled(false);
        if (e.getClass().getName().equals("javax.swing.JTextField"))
          {
            JTextField tf = (JTextField)e;
            tf.setEditable(false);
          }
      }
    else
      throw new RuntimeException(nom+" n'existe pas");
  }

/**
     activer un des composants du formulaire
     @param nom Nom du composant
  */
  public void activer(String nom) throws RuntimeException
  {
    JComponent e = elements.get(nom);
    if (e!=null)
      {
        if (e.getClass().getName().equals("javax.swing.JButton"))
          e.setEnabled(true);
        if (e.getClass().getName().equals("javax.swing.JTextField"))
          {
            JTextField tf = (JTextField)e;
            tf.setEditable(true);
          }
      }
    else
      throw new RuntimeException(nom+" n'existe pas");
  }

/**
     Cette methode permet de choisir un fichier sur le disque
     @param directory nom relatif ou absolu du répertoire initial
     @return retourne le nom absolu fichier sélectionné  ou null si annuler
  **/
  public String choisirFichier(String directory)
  {
    JFileChooser fileChooser = new JFileChooser();
    fileChooser.setCurrentDirectory(new File(directory));
    int result = fileChooser.showOpenDialog(frame);
    if (result == JFileChooser.APPROVE_OPTION) {
      File selectedFile = fileChooser.getSelectedFile();
      return selectedFile.getPath();
    }
    else
      return null;
  }

/**
     Cette methode statique permet de lire un fichier texte
     @param nomFichier le path relatif ou absolu du fichier a lire
     @return un tableau de caractere contenant chaque ligne du fichier
  **/
  public static String[] lireFichierTexte(String nomFichier)
  {
    try{
      File fichier = new File(nomFichier);
      if (! fichier.exists())
        {
          throw new RuntimeException("Le fichier "+nomFichier+" n'existe pas ou n'est pas accessible");
        }
      FileInputStream fis = new FileInputStream(new File(nomFichier));
            
      byte[] buffer = new byte[(int)fichier.length()];
      fis.read(buffer);
      fis.close();
      String str = new String(buffer);

// On enleve le caractère '\r' code 13 qui est ajouté en Windows
      // Les fins de ligne dans un fichier texte créé sous Windows
      //  se termine par \r\n.
      // Il faut enlever le \r car il a des effets perturbant sur
      //  la méthode System.out.print et est pris comme un caractère de plus
      //  qu'il faut éliminer
      //  
      String texte = str.replaceAll(""+(char)(13),"");
            
      // Les lignes du fichier sont mises dans un tableau
      //
      String[] mots = texte.split("\n");

return(mots);
    }
    catch(Exception ex)
      {
        throw new RuntimeException("Erreur dans la lecture du fichier :"+nomFichier);
      }
  }
}

FormulaireInt.java
LigneCanvas.java

package fr.cnam.ihm;

import java.awt.*;

/** Classe de définition d'une ligne dessinée dans le canvas
 **/
public class LigneCanvas extends ObjetCanvas
{
    /** couleur de la ligne (de 1 à 10) **/
    public int marque;
    /** Ressources graphiques **/
    public RessourcesCanvas rc;
    /** 1er point de la ligne **/
    public Point p1;
    /** 2eme point de la ligne **/
    public Point p2;
    
    /**
       Création d'une ligne
       @param marque numéro de couleur (de 1 à 10)
       @param x1 coord X du 1er point
       @param y1 coord Y du 1er point
       @param x2 coord X du 2eme point
       @param y2 coord Y du 2eme point
    **/
    public LigneCanvas(int marque,int x1,int y1,int x2,int y2)
    {
        this.marque=marque;
        this.rc=null;
        p1=new Point();
        p2=new Point();
        p1.x=x1;
        p1.y=y1;
        p2.x=x2;
        p2.y=y2;
    }

/** Création d'une ligne
        @param rc ressources graphiques
        @param x1 coord X du 1er point
        @param y1 coord Y du 1er point
        @param x2 coord X du 2eme point
        @param y2 coord Y du 2eme point
    **/
    public LigneCanvas(RessourcesCanvas rc,int x1,int y1,int x2,int y2)
    {
        this.marque=-1;
        this.rc = rc;
        p1=new Point();
        p2=new Point();
        p1.x=x1;
        p1.y=y1;
        p2.x=x2;
        p2.y=y2;
    }
}

ObjetCanvas.java
PolygoneCanvas.java

package fr.cnam.ihm;

import java.awt.*;
import java.util.*;

import fr.cnam.ihm.*;

/** Classe de définition d'un polygone
 **/
public class PolygoneCanvas extends ObjetCanvas implements Comparable<PolygoneCanvas>
{
    /** marque de couleur de 1 à 10 **/
    public int marque;
    /** ressource graphique **/
    public RessourcesCanvas rc;
    /** les points du polygone **/
    public Point[] points;
    /** le polygone java **/
    public Polygon polygone;
    /** Position en 3D du polygone */
    public Position pos;
    /** Objet associé au polygone **/
    public Object object;
    
    /** Création d'un polygone dans le canvas
        @param o objet quelconque (voir pointerCanvas)
        @param p position en 3D du polygone
        @param marque couleur de 1 à 10
        @param points les points du polygone
    **/
    public PolygoneCanvas(Object o,Position p,int marque,Point... points)
    {
        this.object=o;
        this.points = points;
        this.marque=marque;
        this.rc=null;
        this.pos=p;
        int[] xpoints = new int[points.length];
        int[] ypoints = new int[points.length];
        for(int i=0;i<points.length;i++)
            {
                xpoints[i]=points[i].x;
                ypoints[i]=points[i].y;
            }
        this.polygone = new Polygon(xpoints,ypoints,points.length);
    }

/** Création d'un polygone dans le canvas
        @param rc ressources graphiques du polygone
        @param o objet quelconque (voir pointerCanvas)
        @param p position en 3D du polygone
        @param points les points du polygone
    **/
    public PolygoneCanvas(RessourcesCanvas rc,Object o,Position p,Point... points)
    {
        this.object=o;
        this.points = points;
        this.marque=-1;
        this.rc = rc;
        this.pos=p;
        int[] xpoints = new int[points.length];
        int[] ypoints = new int[points.length];
        for(int i=0;i<points.length;i++)
            {
                xpoints[i]=points[i].x;
                ypoints[i]=points[i].y;
            }
        this.polygone = new Polygon(xpoints,ypoints,points.length);
    }

/** méthode utilisé pour trier les polygones avant de les afficher.
        L'ordre est decroissante sur Z, Y puis Z.
        Cela garantit un effet 3D des polygones.
        @param p Le polygone a compara avec this
        @return retourne l'ordre (-1 inferieur 1 supérieur 0 égal)
    **/
    public int compareTo(PolygoneCanvas p)
    {
        if (pos.z<p.pos.z) return -1;
        else if (pos.z>p.pos.z) return 1;
        else if (pos.y>p.pos.y) return -1;
        else if (pos.y<p.pos.y) return 1;
        else if (pos.x<p.pos.x) return 1;
        else if (pos.x>p.pos.x) return -1;
        else return 0;
    }
}

Position.java

package fr.cnam.ihm;

import java.io.*;

/** Classe de définition d'un position 3D (x,y,z)
 **/
public class Position
{
    /** coordonnée X **/
    public int x;
    /** coordonnée Y **/
    public int y;
    /** coordonnée Z **/
    public int z;

/** Création d'un polygone vide */
    public Position(){}

/** Création d'un polygone.
        @param x coordonnée en X
        @param y coordonnée en Y
        @param z coordonnée en Z
    **/
    public Position(int x,int y, int z)
    {
        this.x=x;this.y=y;this.z=z;
    }
    
    /** clone d'une Position 
        @return retourne le clone de l'objet 
    **/
    public Position clone()
    {
        return new Position(x,y,z);
    }

/** Teste si deux positions ont égales
        @param p positionà tester
        @return vrai si égal sinon faux
     **/
    public boolean equals(Position p)
    {
        return (x==p.x)&&(y==p.y)&&(z==p.z);
    }

/** Ecrire dans un flot de texte le polygone 
        @param ps flot d'écriture texte
        @throws Exception si erreur d'écriture
     **/
    public void ecrire(PrintStream ps) throws Exception
    {
        ps.println(String.format("%d;%d;%d",x,y,z));
    }

/** Lire dans un flot de texte le polygone 
        @param br flot de lecture texte
        @throws Exception si erreur de lecture
     **/
    public void lire(BufferedReader br) throws Exception
    {
        String ligne = br.readLine();
        String[] ts = ligne.split("[;]");
        x=Integer.parseInt(ts[0]);
        y=Integer.parseInt(ts[1]);
        z=Integer.parseInt(ts[2]);
    }

/** Position en chaine
        @return chaine
    **/
    public String toString()
    {
        return String.format("[%d %d %d]",x,y,z);
    }
}

RessourcesCanvas.java

package fr.cnam.ihm;

import java.awt.*;

/** Classe de définition d'une ressources graphiques **/
public class RessourcesCanvas
{
    /** Couleur de background de l'objet **/
    private Color  background;
    /** Couleur de foreground de l'objet **/
    private Color  foreground;
    /** épaisseur de la ligne **/
    private int    line;
    
    /** Création d'une ressource.
        Par défaut : background=blanc foreground=noir ligne=1 
    **/
    public RessourcesCanvas()
    {
        background = new Color(255,255,255);
        foreground = new Color(0,0,0);
        line = 1;
    }

/** Mise à jour du background 
        @param c couleur
    **/
    public void setBackground(Color c){background=c;}

/** Mise à jour du foreground
        @param c couleur
    **/
    public void setForeground(Color c){foreground=c;}

/** Mise de l'épaisseur de la ligne
        @param epaisseur épaisseur de la ligne
    **/
    public void setLine(int epaisseur){line=epaisseur;}

/** Couleur de background de la ressource.
        @return couleur
    **/
    public Color getBackground(){return background;}

/** Couleur de foreground de la ressource.
        @return couleur
    **/
    public Color getForeground(){return foreground;}

/** Epaisseur de la ligne
        @return epaisseur
    **/
    public int getLine(){return line;}
    
}

TexteCanvas.java

package fr.cnam.ihm;

import java.awt.*;

/** Classe de définition d'un texte dessiné dans le canvas
 **/
public class TexteCanvas extends ObjetCanvas
{
    /** Valeur du texte **/
    public String texte;
    /** Cooord du texte **/
    public Point p;
    /** Marque de couleur du texte (de 1 à 10) **/
    public int   couleur;  // de 1 à  10
    /** Ressources graphique du texte **/
    public RessourcesCanvas rc;
    /** font du texte **/
    public Font  font;
    
    /** Création d'un texte dans le canvas
        @param texte valeur du texte
        @param x position en x du texte
        @param y position en y du texte
        @param couleur la couleur du texte (de 1 à 10)
    **/
    public TexteCanvas(String texte,int x,int y,int couleur)
    {
        this.texte=texte;
        this.p=new Point();
        this.p.x=x;
        this.p.y=y;
        this.couleur=couleur;
        this.rc=null;
        this.font=null;
    }

/** Création d'un texte dans le canvas
        @param rc ressources graphiques du texte
        @param texte valeur du texte
        @param x position en x du texte
        @param y position en y du texte
    **/
    public TexteCanvas(RessourcesCanvas rc,String texte,int x,int y)
    {
        this.texte=texte;
        this.p=new Point();
        this.p.x=x;
        this.p.y=y;
        this.couleur=-1;
        this.rc=rc;
        this.font=null;
    }
}

main
TesterCanvasIHM.java

package fr.cnam.main;

import java.util.*;
import java.awt.*;

import fr.cnam.ihm.*;
import fr.cnam.tore.*;

public class TesterCanvasIHM
{
    /** Méthode de test de la classe.
        Ce programme crée un canvas dans lequel il est possible de dessiner des lignes, des point et des textes.
        Les boutons permettent de tester le canvas.
    */
    public static void main(String... args)
    {
        Test t = new Test();
    }

}

// ===============================================================
/** Classe utilisée pour tester 
 */
class Test implements FormulaireInt, ControlesCanvasIHM
{
    private CanvasIHM canvas;
    private int mode;
    private int posxc;
    private int posyc;
    Formulaire form;
    private boolean debutTrace;
    private boolean courantTrace;
    private int numPoint;

public Test()
    {
        // 
        mode=0;
        debutTrace=false;
        courantTrace=false;

// Creation d'un formuaire qui contient des boutons et le canvas
        //
        form = new Formulaire("TESTER",this,310+600+30,
                              600+30);
        // -- les boutons
        form.horizontal();
        form.setWidthButtonCour(200);
        form.addButton("DESSINER_LIGNE","Dessiner une ligne");
        form.addButton("EFFACER","Effacer");
        form.addButton("AFFICHER_POLYGONES","Afficher des polygones");
        form.vertical();
        form.dessous(0);
        form.setWidthTextCour(400);
        form.addText("INFO","info",false,"");
        form.dessous(0);

// -- création du canvas
        canvas = form.addCanvasIHM(600,600,this);
        canvas.getPanel().setBackground(Color.yellow);

// Affichage du formulaire
        form.afficher(50,50);
    }

// La methode a implementer de l'interface FormualireInt pour le formulaire
    //
    public void  submit(Formulaire form,String nom)
    {
        // Les méthodes concernant le canvas que vous pouvez utiliser sont :
        //
        // public void ajouterLigne(int couleur,int x1,int y1,int x2,int y2)
        //
        // public void ajouterTexte(String texte,int x,int y,int couleur)
        //
        // public void ajouterPolygone(Object o,Position p,int couleur,Point... points)
        //
        // public void effacerCanvas()
        //
        // public JPanel getPanel()
        //
        //
        //
        //
        courantTrace=false;

if (nom.equals("DESSINER_LIGNE")) 
            {
                form.setValeurChamp("INFO","Cliquer plusieurs fois dans le canvas");
                
                mode = 1;
                debutTrace = true;
            }

if (nom.equals("EFFACER")) 
            {
                canvas.effacerCanvas();
            }

if (nom.equals("AFFICHER_POLYGONES")) 
            {
                canvas.effacerCanvas();
                Random rdm = new Random();
                
                for(int k=0;k<5;k++)
                    for(int i=0;i<100/(k+1);i++)
                    {
                        Position p = new Position(rdm.nextInt(20),rdm.nextInt(20),k);
                        afficherCube(p,p,k);
                    }
            }
    }

// action quand on clique dans le canvas
    //
    public void pointerCanvas(Object target,int x,int y,CanvasIHM canvas)
    {
        form.setValeurChamp("INFO","");
        if (debutTrace)
            {
                debutTrace=false;
                courantTrace=true;
                this.posxc = x;
                this.posyc = y;
                this.numPoint = 1;
            }
        else if (courantTrace)
            {
                canvas.ajouterLigne(3,this.posxc,this.posyc,x,y);
                canvas.ajouterTexte("Point "+this.numPoint,this.posxc,this.posyc,6);
                this.numPoint++;
                this.posxc = x;
                this.posyc = y;
            }

if (target!=null)
            {
                Position pos = (Position)target;
                System.out.println(String.format("[%d %d %d]",
                                                 pos.x,
                                                 pos.y,
                                                 pos.z));
            }
    }

// Non utilise ici
    //
    public void pointerCaseGrille(int xCase,int yCase,CanvasIHM ihm)
    {
    }

// Afficher un cube en 3D
    //
    private void afficherCube(Object obj,Position p,int couleur)
    {
        double pzXPourc=0.6;
        double pzYPourc=0.3;
        int pas = 20;
        int pzX = (int)((double)pas*pzXPourc);
        int pzY = (int)((double)pas*pzYPourc);

int origineX=20+p.z*pzX;
        int origineY=20+p.z*pzY;
        int px=p.x;
        int py=p.y;

Color col1,col2,col3;

ArrayList<Color> table = new ArrayList<Color>();
        int[] plage={0,128,255};
        
        table.add(new Color(255,0,0));
        table.add(new Color(0,255,0));
        table.add(new Color(0,0,255));

table.add(new Color(255,255,0));
        table.add(new Color(0,255,255));
        table.add(new Color(255,0,255));

table.add(new Color(128,255,0));
        table.add(new Color(0,128,255));
        table.add(new Color(128,0,255));

table.add(new Color(255,128,0));
        table.add(new Color(0,255,128));
        table.add(new Color(255,0,128));

table.add(new Color(128,128,0));
        table.add(new Color(0,128,128));
        table.add(new Color(128,0,128));

table.add(new Color(128,0,0));
        table.add(new Color(0,128,0));
        table.add(new Color(0,0,128));

if( (couleur<0)||(couleur>=table.size()) )
            col1 = new Color(125,125,125);
        else
            col1 = table.get(couleur);
        
        double[] polaire = polaire(col1.getRed(),col1.getGreen(),col1.getBlue());
        double r2 = polaire[0]*0.66;
        double r3 = polaire[0]*0.44;
        double[] cart2 = cartesienne(r2,polaire[1],polaire[2]);
        double[] cart3 = cartesienne(r3,polaire[1],polaire[2]);
        
        col2 = new Color((int)cart2[0],(int)cart2[1],(int)cart2[2]);
        col3 = new Color((int)cart3[0],(int)cart3[1],(int)cart3[2]);

// Face de cote gauche
        RessourcesCanvas rc = new RessourcesCanvas();
        rc.setBackground(col3);
        canvas.ajouterPolygone(rc,obj,p,new Point(px*pas+origineX,py*pas+origineY),
                               new Point(px*pas+origineX+pzX,py*pas+origineY+pzY),
                               new Point((px)*pas+origineX+pzX,(py+1)*pas+origineY+pzY),
                               new Point((px)*pas+origineX,(py+1)*pas+origineY));

//Face du haut
        rc = new RessourcesCanvas();
        rc.setBackground(col1);
        canvas.ajouterPolygone(rc,obj,p,new Point(px*pas+origineX,py*pas+origineY),
                               new Point((px+1)*pas+origineX,py*pas+origineY),
                               new Point((px+1)*pas+origineX+pzX,py*pas+origineY+pzY),
                               new Point((px)*pas+origineX+pzX,(py)*pas+origineY+pzY));
        
        //Face de devant
        rc = new RessourcesCanvas();
        rc.setBackground(col2);
        canvas.ajouterPolygone(rc,obj,p,new Point(px*pas+origineX+pzX,py*pas+origineY+pzY),
                               new Point((px+1)*pas+origineX+pzX,py*pas+origineY+pzY),
                               new Point((px+1)*pas+origineX+pzX,(py+1)*pas+origineY+pzY),
                               new Point((px)*pas+origineX+pzX,(py+1)*pas+origineY+pzY));
                                           
    }

// Conversion de coord cartesienne en coord polaire dans un
    //   espace 3D
    //
    static double[] polaire(double x,double y,double z)
    {
        double[] pol = new double[3];
        double r=Math.sqrt(x*x+y*y);
        pol[0]=Math.sqrt(r*r+z*z);   // R
        pol[1]=Math.acos(x/r);       // teta
        pol[2]=Math.asin(z/pol[0]);  // phi

return pol;
    }

// Conversion de coord polaire en coord cartesienne dans un
    //  espace 3D
    //
    static double[] cartesienne(double R,double teta,double phi)
    {
        double[] cart = new double[3];
        double r = R*Math.cos(phi);
        cart[0]=r*Math.cos(teta);
        cart[1]=r*Math.sin(teta);
        cart[2]=R*Math.sin(phi);
        for(int i=0;i<3;i++)
            {
                if (cart[i]<0) cart[i]=120;
                if (cart[i]>255) cart[i]=120;
            }
    
        return cart;
    }

}

TesterFormulaire.java

package fr.cnam.main;

import java.util.*;
import java.awt.*;
import javax.swing.*;

import fr.cnam.ihm.*;
import fr.cnam.tore.*;

/** Programme de test d'un formulaire
 */
public class TesterFormulaire implements FormulaireInt,ControlesCanvasIHM
{
    /** historique courant
         L'historique est utilise pour afficher les resultats
         des traitements **/
    private String historique;

/** Couleur courante selectionne **/
    public int couleur;

public JLabel image1;
    
    /** Constructeur
     **/
    public TesterFormulaire()
    {
        // Les attributs de la classe
        historique = "";
        couleur=1;

// Affichage d'un formulaire qui calcule l'addition de deux entiers
        //
        Formulaire form = new Formulaire("TESTER",this,700,600,true);

form.setTailleFonte(20);
        form.setHeightText(30);
        form.setAutoWidth(true);
        form.addLabel("Faire l'addition de deux entiers :");
        form.addText("val1","Valeur 1 :",true,"123");
        form.addText("val2","Valeur 2",true,"456");
        form.setWidthButtonCour(150);
        form.addButton("add","Additionner");
        form.addLabel("");

// Selection d'une valeur dans une liste de valeurs dans un ListScroll
        //
        String[] values = { "la belle de nuit", "la fille de l'air","le garçon manqué","abcdefghijklmnopqrstuvwxyz","111","2222","3333"};
        form.addListScroll("LIST","Zone ",true,values,200,100);
        form.addButton("SELECTION","SELECTION");

// Selection d'une valeur dans un popup menu
        //
        form.addLabel("");
        String[] l = {"HOMME","FEMME","ENFANT"};
        form.addListeChoix("CHOIX","Choisir",l,true,"FEMME");

// Choisir un fichier texte et afficher son contenu
        //
        form.addLabel("");
        form.addButton("CHOISIR_FICHIER","Choisir un fichier");

int xpos = form.getXCour();
        int ypos= form.getYCour();

form.setPosition(300,10);
        form.addZoneText("zone","Historique",true,"",300,500);

form.addButton("exit","Fermer la fenetre");
        form.setButtonFermer("exit");

image1 = form.addImage("IMAGE 1",xpos,ypos,71,96,"images/cards_gif/ck.gif",true);
        JLabel image2 = form.addImage("NONE",xpos+80,ypos,71,96,"images/cards_gif/cq.gif",false);

form.afficher();   // Afficher le formulaire

// Un autre exemple de formulaire pour montrer les possibilités de positionnement
        //
        Formulaire form2 = new Formulaire("TESTER",this,1200,600,true);
        
        form2.setPosition(10,10);
        form2.horizontal();
        form2.addText("Exemple","Exemple",true,"ABCDE");
        form2.addPosition(50,form2.getYCour());
        form2.addText("Champ1","Champ1",true,""); 
        form2.dessous(10);
        form2.vertical();
        form2.setWidthButtonCour(50);
        form2.addButton("B1","B1"); 
        form2.addButton("B2","B2");
        form2.horizontal();
        form2.addButton("B3","B3");
        form2.addButton("B4","B4"); //x=100 et en dessous par defaut
        form2.addButton("B5","B5"); 
        form2.dessous(30);
        form2.vertical();
        form2.addText("Champ2","Champ2",false,"222"); // non editable
        form2.addText("Champ3","Champ3",true,"33333");
        form2.setPosition(300,100);
        form2.vertical();
        form2.addZoneText("z1","Zone 1",true,"",300,100);
        form2.addZoneText("z2","Zone 2",true,"",100,100);
        form2.addText("z4","Champ4",true,"33333");
        form2.setPosition(650,10);
        form2.addGrilleIHM(10,10,20,this);
        form2.setWidthButtonCour(150);
        form2.addButton("Couleur1","Couleur1");
        form2.addButton("Couleur2","Couleur2");
        form2.addButton("Couleur3","Couleur3");
        form2.addButton("Couleur4","Couleur4");
        form2.afficher();

}  // Fin du constructeur

/** Recuperation des actions dans les boutons des
       deux formulaires
       @param form Le formulaire utilise
       @param nomSubmit nom du bouton selectionne
    **/
    public void submit(Formulaire form,String nomSubmit)
    {
        if (nomSubmit.equals("add"))
            {
                try{
                    String s1 = form.getValeurChamp("val1");
                    String s2 = form.getValeurChamp("val2");
                    int v1 = Integer.parseInt(s1);
                    int v2 = Integer.parseInt(s2);
                    
                    historique = historique+String.format("%5d + %5d = %7d\n",v1,v2,v1+v2);
                }catch(Exception ex)
                    {
                        historique = historique+ex.getMessage()+"\n";
                    }
            }
        if (nomSubmit.equals("SELECTION"))
            {
                historique = historique + ">> "+ form.getValeurChamp("LIST")+"\n";
            }
        if (nomSubmit.equals("CHOIX"))
            {
                String choix =  form.getValeurChamp("CHOIX");
                historique = historique + "CHOIX:"+choix+"\n";
            }

if (nomSubmit.equals("B1"))
            {
                form.desactiver("B3");
            }
        if (nomSubmit.equals("B2"))
            {
                form.activer("B3");
            }
        if (nomSubmit.equals("B4"))
            {
                form.activer("Champ2");
            }
        if (nomSubmit.equals("B5"))
            {
                form.desactiver("Champ2");
            }
        if (nomSubmit.equals("Couleur1")) couleur=1;
        if (nomSubmit.equals("Couleur2")) couleur=2;
        if (nomSubmit.equals("Couleur3")) couleur=3;
        if (nomSubmit.equals("Couleur4")) couleur=4;

if (nomSubmit.equals("CHOISIR_FICHIER"))
            {
                try{
                    String fichier = form.choisirFichier("../fr/cnam/ihm");
                    historique = historique + "NOM FICHIER : "+fichier +"\n";
                    String[] lignes = form.lireFichierTexte(fichier);
                    for(String s:lignes)
                        {
                            historique = historique + s +"\n";
                        }
                }
                catch(Exception ex)
                    {
                        historique = historique + ex + "\n";
                    }
                
            }

if (nomSubmit.equals("IMAGE 1"))
          {
            historique = historique + "Click IMAGE 1\n";
            String[] coul={"c","d","s","h"};
            int n=new Random(System.currentTimeMillis()).nextInt(9)+1;
            String c =coul[new Random(System.currentTimeMillis()).nextInt(4)];
            form.setImage(image1,"images/cards_gif/"+c+n+".gif");
          }

// Mise a jour de la zone avec l'historique courant
        form.setValeurChamp("zone",historique);
    }

/** Methode appele quand on clique dans une des cases de la grille
     **/
    public void pointerCaseGrille(int xCase,int yCase,CanvasIHM ihm)
    {
        //point = new Point(xCase,yCase);
        ihm.setMarque(couleur,xCase,yCase);
    }

/** Pas utilise ici car pas de Canvas
     **/
    public void pointerCanvas(Object target,int x,int y,CanvasIHM ihm)
    {
    }

/** Methode main
        Pour lancer le programme de test
     **/
    public static void main(String... args)
    {
        new TesterFormulaire();
    }
}

TesterGrilleIHM.java

package fr.cnam.main;

import java.util.*;
import java.awt.Point;

import fr.cnam.ihm.*;
import fr.cnam.tore.*;

public class TesterGrilleIHM 
{
    /** Méthode de test de la classe.
        Ce programme crée une grille et crée un thread qui déplace une case.
        Les boutons permettent de tester le comportement du déplacement
    */
    public static void main(String... args)
    {
        TestThread t = new TestThread();

// Démarrage du test
        t.start();
    }

}

// ===============================================================
/** Classe utilisée pour tester la classe Tore et la grille
 */
class TestThread extends Thread implements FormulaireInt
{
    private CanvasIHM grille;
    private int mode;
    private Point point;

public TestThread()
    {
        // MOde de deplacement de l'agent par defaut
        mode=1;
        point = new Point(30,30);

// Creation d'un formuaire qui contient des boutons et la grille
        //
        Formulaire form = new Formulaire("TESTER",this,1200,800);

// -- les boutons
        form.setWidthButtonCour(300);
        form.addButton("DEP_ALEAT","Dep aleat");
        form.addButton("LE_PLUS_PROCHE","Le plus proche des coins");
        form.addButton("VERS_5_5","Vers le point (5,5)");
        form.addButton("VERS_POINT","Vers le point designe");
        
        // -- la grille
        // Pour verifier les actions dans la grille.
        // Etant donne que la classe herite deja de Thread on ne peut pas la faire heriter de
        //  AdaptaterControlesCanvasIHM et mettre this dans l'appel de la methode setAction.
        // On utilise une inner classe TestActions qui va heriter de l'adaptater
        //  
        grille = form.addGrilleIHM(40,40,15,new TestActions());
        
        // Affichage du formulaire
        form.afficher(50,50);

// On met des couleurs à certaines case
        grille.setMarque(1,0,0);  // Couleur 1 en case (0,0)
        grille.setMarque(2,0,1);  // Couleur 1 en case (0,1)
        grille.setMarque(3,0,2);  // Couleur 1 en case (0,2)
        grille.setMarque(4,0,3);  // Couleur 1 en case (0,3)
        grille.setMarque(5,0,4);  // Couleur 1 en case (0,4)
        grille.setMarque(6,0,5);  // Couleur 1 en case (0,5)
        grille.setMarque(7,0,6);  // Couleur 1 en case (0,6)
        grille.setMarque(8,0,7);  // Couleur 1 en case (0,7)
        grille.setMarque(9,0,8);  // Couleur 1 en case (0,8)

}

// Le traitement du thread
    //
    public void run()
    {
        // Pour faire du calcul aleatoire
        Random  rdm = new Random();

// Pour faire du calcul dans un espace mathematique de Tore
        Tore espace = new Tore(grille.getNbX(),grille.getNbY());

// P
        int x=grille.getNbX()/2;
        int y=grille.getNbY()/2;
        grille.setMarque(1,x,y);

//
        while(true)
            {
                // deplacement d'une case noire aleatoirement dans les 9 directions
                if (mode==1)
                    {
                        int sensX = rdm.nextInt(3)-1;
                        int sensY = rdm.nextInt(3)-1;

// La methode deplacer applique le sensX sensY a x et y en tenant compte
                        //   que nous sommes dans un Tore
                        Point p = espace.deplacer(x,y,sensX,sensY);

// On "depalce" le carre noir dans la grille
                        grille.setMarque(0,x,y);
                        x = (int)p.x;
                        y = (int)p.y;
                        grille.setMarque(1,x,y);
                    }

// deplacement vers le plus proche de certains points.
                // On a pris par exemple les 4 coins
                if (mode==2)
                    {
                        // On prend les 4 coins comme points
                        Vector points = new Vector();
                        points.add( (Point)(new Point(0,0) ));
                        points.add( (Point)(new Point(grille.getNbX()-1,0) ));
                        points.add( (Point)(new Point(0,grille.getNbY()-1) ));
                        points.add( (Point)(new Point(grille.getNbX()-1,grille.getNbY()-1) ));

// On determine le point plus proche inferieur a un seuil de 5
                        //
                        Point pointProche = espace.lePlusProche(new Point(x,y),points,5);

// Si il n'y en a pas alors rien
                        if (pointProche != null)
                            {
                                // Determination du sens de deplacement entre la position courante
                                //  et le point le plus proche
                                Point sens = espace.sensTore(new Point(x,y),pointProche);

Point p = espace.deplacer(x,y,sens.x,sens.y);

grille.setMarque(0,x,y);
                                x = p.x;
                                y = p.y;
                                grille.setMarque(1,x,y);
                            }
                    }

// deplacement de la case noire de 1 pas de case en direction du point (5,5)
                //
                if (mode==3)
                    {
                        // Cette méthode determine le vecteur unitaire dans un espace de Tore du
                        //  point (x,y) vers le point du milieur de la grille
                        //
                        Point sens = espace.sensTore(new Point(x,y),new Point(5,5));

// Le vecteur unitaire est un sens de deplacement
                        Point p = espace.deplacer(x,y,sens.x,sens.y);

// deplacement de la case noire de 1 pas de case en direction du point (30,30)
                //
                if (mode==4)
                    {
                        // Cette méthode determine le vecteur unitaire dans un espace de Tore du
                        //  point (x,y) vers le point 
                        //
                        Point sens = espace.sensTore(new Point(x,y),point);

// Le vecteur unitaire est un sens de deplacement
                        Point p = espace.deplacer(x,y,sens.x,sens.y);

// On "depalce" le carre noir dans la grille
                        grille.setMarque(0,x,y);
                        x = (int)p.x;
                        y = (int)p.y;
                        grille.setMarque(1,x,y);
                    }
                
                try{Thread.sleep(200);}catch(Exception ex){};
            }
    }

// La methode a implementer de l'interface FormualireInt pour le formulaire
    //
    public void     submit(Formulaire form,String nom)
    {
        // Pour changer le comportement de deplacement
        //
        if (nom.equals("DEP_ALEAT")) mode = 1;
        if (nom.equals("LE_PLUS_PROCHE")) mode = 2;
        if (nom.equals("VERS_5_5")) mode = 3;
        if (nom.equals("VERS_POINT")) mode = 4;
    }

// Etant donne que la classe herite deja de Thread on ne peut pas la faire heriter de
    //  AdaptaterControlesCanvasIHM. On cree donc une inner classe qui en herite et 
    //  
    class TestActions implements ControlesCanvasIHM
    {
        public void pointerCaseGrille(int xCase,int yCase,CanvasIHM ihm)
        {
            point = new Point(xCase,yCase);
            ihm.setMarque(4,xCase,yCase);
        }

public void pointerCanvas(Object target,int x,int y,CanvasIHM ihm)
        {
        }

}
}

tore
Tore.java

// Fichier: Tore.java
// Par: J. Laforgue
//
// Ce fichier doit appartenir au package Tore.
//
// Il contient des methodes statiques permettant de realiser des
// operations vectorielles dans un espace de Tore
//
package fr.cnam.tore;

import java.awt.Point;
import java.util.Vector;

/**
  Classe d'implémentation d'un espace rectangulaire orthonormé de Tore
*/
public class Tore
{
    private int nbX; // Taille en colonne (largeur) de l'espace
    private int nbY; // Taille en ligne (hauteur) de l'espace
    
    /** Création d'un espace de Tore défini par sa longueur et sa hauteur
        @param width longueur (pixel)
        @param height largeur (pixel)
    */
    public Tore(int width, int height)
    {
        this.nbX = width;
        this.nbY = height;
    }

/**
        Cette methode retourne l'image de B par rapporrt a A, c'est a dire le point le plus proche de A dans un espace de tore
        @param A : coordonnees du point A
        @param B : coordonnees du point B
        @return coordonnees de l'image de B
    */
    public Point image(Point A,
                       Point B)
    {
        int xA;
        int yA;
        int xB;
        int yB;
        int x;
        int y;
        double min;
        double distance;
        
        xA = (int)(A.x);
        yA = (int)(A.y);
        xB = (int)(B.x);
        yB = (int)(B.y);
        
        x=0;
        y=0;
        
        int TX[] = new int[3];
        int TY[] = new int[3];
        TX[0] = -nbX+xB;
        TX[1] = xB;
        TX[2] = nbX+xB;
        TY[0] = -nbY+yB;
        TY[1] = yB;
        TY[2] = nbY+yB;
        
        min=9*(nbX*nbX+nbY*nbY);
        for(int i=0;i<3;i++)
            {
                for(int j=0;j<3;j++)
                    {
                        xB = TX[i] - xA;
                        yB = TY[j] - yA;
                        distance = Math.sqrt(xB*xB+yB*yB);
                        if (distance < min)
                            {
                                min = distance;
                                x = TX[i];
                                y = TY[j];
                            }
                    }
            }
        return ( new Point(x,y) );
    }
    
    // retourne la distance entre 2 points
    //
    static private double distance(Point p1, Point p2)
    {
        return ( Math.sqrt( (p2.x - p1.x)*(p2.x - p1.x) +
                            (p2.y - p1.y)*(p2.y - p1.y) ));
    }

/**
       Retourne le sens du vecteur (ou vecteur unitaire) de A vers B dans l'espace de Tore. 
       Cela correspond au vecteur de A vers l'image de B. 
       @param A le point A
       @param B le point B
       @return la direction ( (-1,O,+1)(ex: (-1,-1) (1,0), ...)
     */
    public Point sensTore(Point A,
                          Point B)
    {
        return sens(A,image(A,B));
    }

/**
     Cette methode consiste à déterminer le point le plus proche de A dans un espace de Tore parmi un ensemble de points ET dont la distance est superieur à une distance seuil.
     @param A coordonnees du point A
     @param points Ensemble des points
     @param distanceSeuil disnance seuil
     @return le point le plus proche 
     si il n'existe pas de tel point alors retourne null. Grace au seuil il ne sera pas pris en consideration. (Sauf si ce seuil est egal a 0).
      
     Remarque: A peut appartenir à l'ensemble des points.
    */
    public Point lePlusProche(Point A,
                              Vector points,
                              int distanceSeuil)
    {
        double min;
        double dis;
        Point image;
        Point p = null;
        Point pcour;
        
        if (points == null) return(p);
        if (points.size() == 0) return(p);
        
        min = 999999;
        
        for(int i=0;i<points.size();i++)
            {
                pcour = (Point)(points.get(i));
                if (! pcour.equals(A))
                    {
                        image = image(A,pcour);
                        dis = distance(A,image);
                        if ( (dis<min) && (dis>(double)distanceSeuil) )
                            {
                                min=dis;
                                p = image;
                            }
                    }
            }
        return(p);
    }
    
    /**
     Cette methode retourne le vecteur unitaire du vecteur AB dans un espace normal euclidien orthonorme (ne tient pas compte du tore).
     @param A le point A
     @param B le point B
     @return La valeur de retour est de la forme (+1,+1) , (+1,-1), (+1,0), ....
    */
    public Point sens(Point A,Point B)
    {
        int sensX;
        int sensY;
        
        // Vecteur AB
        int x = (int)B.x - (int)A.x;
        int y = (int)B.y - (int)A.y;
        
        // Norme du vecteur
        double norme = Math.sqrt(x*x+y*y);
        
        // Vecteur unitaire vers ce point le plus proche
        double dx = (double)x/norme;
        double dy = (double)y/norme;
        
        // On definie le sens en X et Y afin de se diriger vers B
        sensX=0;
        if (dx>0.5){sensX=1;}
        if (dx<-0.5){sensX=-1;}
        sensY=0;
        if (dy>0.5){sensY=1;}
        if (dy<-0.5){sensY=-1;}
        
        return( new Point(sensX,sensY));
    }
    
    /**
       Calcule les nouvelles coordonnées d'un point en fonction de son déplacment d'une case dans une des 8 directions. 
       Le calcul tient compte du Tore.
       @param x coordonnée en x du point
       @param y coordonnée en y du point
       @param sensX direction en X (-1, 0, +1)
       @param sensY direction en Y (-1, 0, +1)
       @return les nouvelles coordonnées du point
    */
    public Point deplacer(int x,int y,int sensX,int sensY)
    {
        int xn = x+sensX;
        int yn = y+sensY;
        
        if (xn<0) { xn=nbX-1; }
        if (xn>=nbX) { xn=0; }
        if (yn<0) { yn=nbY-1; }
        if (yn>=nbY) { yn=0; }
        
        return (new Point(xn,yn));
    }
}

Ces outils sont des packages de code facilitant la réalisation des exmeples, exercices et projets. Ils sont utilisés dans les cours de NFA 031, NFA032 et NSY102 Chaque outil est téléchargeable(zip) et consultable en ligne .