LINELAYOUT : LAYOUT MANAGER POUR PLACEMENT SUR UN AXE

import java.awt.LayoutManager;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Container;
import java.awt.Insets;

/**
 * Cette classe peut tout a fait imiter le comportement du flow layout
 * Trois choses ont été ajouté en plus :
 * - choisir l'axe de placement, plus seulement en abscisse
 * - choisir le ou les axes d'extensions des composants
 * - choisir l'alignement dans le ou les axes souhaités
 * 
 * @author nico
 */

public class LineLayout implements LayoutManager {
   private int orientation = HORIZONTAL;
   
   public static int VERTICAL = 2;
   public static int HORIZONTAL = 3;
   
   private int etirer = NONE;
   
   public static int NONE = 0;
   public static int BOTH = 1;
 
   // comportement de l'alignement
   private int alignementVertical = NONE;
   private int alignementHorizontal = NONE;
   
   public static int CENTER = 1;
   public static int LEFT = 2;
   public static int RIGHT = 3;
   public static int TOP = 4;
   public static int BOTTOM = 5;
   
   // espace lattéral entre les composants
   private int espaceHorizontal = 1;
   private int espaceVertical = 1;

   /**
    * Layout par défaut
    */
   public LineLayout(){}

   /**
    * avec 1 paramètre
    * @param orientation définit l'axe de placement des composants
    */
   public LineLayout(int orientation){
      this.orientation = orientation;
   }
   
   /**
    * avec 2 paramètres
    * @param orientation définit l'axe de placement des composants
    * @param etirer definit l'axe ou les axes d'étirement
    */
   public LineLayout(int orientation, int etirer){
      this.orientation = orientation;
      this.etirer = etirer;     
   }

   /**
    * avec 4 paramètres
    * @param orientation définit l'axe de placement des composants
    * @param etirer definit l'axe ou les axes d'étirement
    * @param alignementHorizontal
    * @param alignementVertical
    */
   public LineLayout(int orientation,
         int etirer,
         int alignementHorizontal,
         int alignementVertical){
      this.orientation = orientation;
      this.etirer = etirer;

      this.alignementVertical = alignementVertical;
      this.alignementHorizontal = alignementHorizontal;
   }
   
   	/**
	 * 
	 * @param orientation
	 * @param etirer
	 * @param alignementHorizontal
	 * @param alignementVertical
	 * @param espaceHorizontal
	 * @param espaceVertical
	 */
   public LineLayout(int orientation, 
         int etirer, 
         int alignementHorizontal, 
         int alignementVertical, 
         int espaceHorizontal, 
         int espaceVertical) {
      this.orientation = orientation;
      this.etirer = etirer;

      this.alignementVertical = alignementVertical;
      this.alignementHorizontal = alignementHorizontal;

      this.espaceHorizontal = espaceHorizontal;
      this.espaceVertical = espaceVertical;
   }

   
   
   /**
    * Ajoute un composant avec une contrainte particuliére, inutile ici, mais
    * laissé pour implémenté l'interface LayoutManager
    */
   public void addLayoutComponent(String name, Component comp) {}

   /**
    * Retire un composant du rendu, inutile ici, mias laissé pour implémenté
    * l'interface LayoutManager
    */
   public void removeLayoutComponent(Component comp) {}

   /**
    * Calcul la dimension préférée du conteneur en paramètre
    */
   public Dimension preferredLayoutSize(Container parent) {
      //On récupère le nombre de composant contenus
      int nb = parent.getComponentCount();
      //On initialise la réponse
      Dimension reponse = new Dimension(0, 0);
      //Pour chaque composant dans le conteneur
      for (int i = 0; i < nb; i++) {
         //Si le composant actuel est affiché
         if (parent.getComponent(i).isVisible()) {
            //On récupère les dimensions préférées du composant actuel
            Dimension actuel = parent.getComponent(i).getPreferredSize();
            //La largeur totale est le maximum des largeurs
            if (reponse.width < actuel.width)
               reponse.width = actuel.width;
            //On ajoute la hauteur du composant actuel
            reponse.height += actuel.height;
         }
      }
      //On tiens en compte des divers décalages
      Insets insets = parent.getInsets();
      reponse.width += insets.right + insets.left + espaceHorizontal * 2;
      reponse.height += insets.top + insets.bottom + espaceVertical * 2;
      //On renvoie la réponse
      return reponse;
   }

   /**
    * Calcul la dimension minimale du conteneur en paramètre
    */
   public Dimension minimumLayoutSize(Container parent) {
      //On récupère le nombre de composant contenus
      int nb = parent.getComponentCount();
      //On initialise la réponse
      Dimension retour = new Dimension(0, 0);
      //Pour chaque composant dans le conteneur
      for (int i = 0; i < nb; i++) {
         //Si le composant actuel est affiché
         if (parent.getComponent(i).isVisible()) {
            //On récupère les dimensions minimales du composant actuel
            Dimension actuelle = parent.getComponent(i).getMinimumSize();

            if(orientation == VERTICAL){
               if (retour.width < actuelle.width)
                  retour.width = actuelle.width;

               retour.height += actuelle.height + espaceVertical;
            } else {
               if (retour.height < actuelle.height)
                  retour.height = actuelle.height;

               retour.width += actuelle.width + espaceHorizontal;
            }
         }
      }
      
      //On tiens compte des divers décalages
      Insets insets = parent.getInsets();
      retour.width += insets.right + insets.left + espaceHorizontal * 2;
      retour.height += insets.top + insets.bottom + espaceVertical * 2;
      //On renvoie la réponse
      
      return retour;
   }

   /**
    * Place les composants dans le conteneur
    */
   public void layoutContainer(Container parent) {
      //On se synchronize sur le conteneur pour éviter des défauts d'affichage
      synchronized (parent.getTreeLock()) {
         //On récupère le décalage du conteneur
         Insets insets = parent.getInsets();

         // Nombre de composants du conteneur
         int nb = parent.getComponentCount();
         int nbVisible = 0;
        
         
         int largeurTotale = 0;
         int hauteurTotale = 0;
         
         for (int i = 0; i < nb; i++) {
            // Si le composant actuel est visible
            if (parent.getComponent(i).isVisible()) {
               // On récupére la taille préferée du composant
               Dimension d = parent.getComponent(i).getPreferredSize();
               
               // Et on redimensionne le composant en fonction des variables
               if(etirer != NONE)
               if(orientation == VERTICAL){
                  if(etirer == BOTH){
                     d.width = parent.getWidth() - 2 * espaceVertical;
                     d.height = (parent.getHeight()) / nb - espaceVertical;
                  } else if(etirer == HORIZONTAL){
                     d.width = parent.getWidth() - 2 * espaceVertical;
                  } else if(etirer == VERTICAL){
                     d.height = (parent.getHeight()) / nb  - espaceVertical;
                  }
               } else {
                  if(etirer == BOTH){
                     d.width = (parent.getWidth()) / nb  - espaceHorizontal;
                     d.height = parent.getHeight() - 2 * espaceHorizontal;                     
                  } else if(etirer == HORIZONTAL){
                     d.width = (parent.getWidth()) / nb - espaceHorizontal;
                  } else if(etirer == VERTICAL){
                     d.height = parent.getHeight() - 2 * espaceHorizontal;
                  }
               }
               
               // On donne au composant la taille préférée qu'on a peut être modifiée
               parent.getComponent(i).setSize(d);
               
               largeurTotale += d.width;
               hauteurTotale += d.height;
               
               nbVisible ++;
            }
            
         }
         
         largeurTotale += nbVisible * espaceHorizontal;
         hauteurTotale += nbVisible * espaceVertical;

         // coordonnées de placement
         int x = espaceVertical + insets.left;
         int y = espaceHorizontal + insets.top;
         
         for (int i = 0; i < nb; i++) {
            //Si le composant actuel est visible
            if (parent.getComponent(i).isVisible()) {
               //On place le composant
               int nouvelX = x;
               int nouvelY = y;
               
               if(etirer != HORIZONTAL && etirer != BOTH){ 
                  // on ne change l'alignement que si on a pas étiré sur l'axe des 
                  if(alignementHorizontal == RIGHT){
                     nouvelX = parent.getWidth() - parent.getComponent(i).getWidth() - espaceHorizontal;
                  } else if(alignementHorizontal == CENTER){
                     if(orientation == VERTICAL){
                        nouvelX = (parent.getWidth() - parent.getComponent(i).getWidth()) / 2;                                                                     
                     } else {
                        nouvelX += (parent.getWidth() - largeurTotale) / 2;                                             
                     }
                  }
               }   
               
               if(etirer != VERTICAL && etirer != BOTH){
                  if(alignementVertical == BOTTOM){
                     System.out.println("ici");
                     nouvelY = parent.getHeight() - y - parent.getComponent(i).getHeight();
                  } else if(alignementVertical == CENTER){
                     if(orientation == VERTICAL){
                        nouvelY += (parent.getHeight() - hauteurTotale) / 2;                                             
                     } else {
                        nouvelY = (parent.getHeight() - parent.getComponent(i).getHeight()) / 2;
                     }
                  }                     
               }
               
               
               parent.getComponent(i).setLocation(nouvelX,nouvelY);
               
               // On incrémente les ordonnées et les abscisses, pour décaler les éléments si besoin est
               if(orientation == VERTICAL){
                  y += parent.getComponent(i).getSize().height + espaceVertical;                  
               } else {
                  x += parent.getComponent(i).getSize().width + espaceHorizontal;
               }
            }
         }
      }
   }
   
   
   
   
   // GETTERS SETTERS
   public int getAlignementHorizontal() {
      return this.alignementHorizontal;
   }
   public void setAlignementHorizontal(int alignementHorizontal) {
      this.alignementHorizontal = alignementHorizontal;
   }
   public int getAlignementVertical() {
      return this.alignementVertical;
   }
   public void setAlignementVertical(int alignementVertical) {
      this.alignementVertical = alignementVertical;
   }
   public int getEspaceHorizontal() {
      return this.espaceHorizontal;
   }
   public void setEspaceHorizontal(int espaceHorizontal) {
      this.espaceHorizontal = espaceHorizontal;
   }
   public int getEspaceVertical() {
      return this.espaceVertical;
   }
   public void setEspaceVertical(int espaceVertical) {
      this.espaceVertical = espaceVertical;
   }
   public int getEtirer() {
      return this.etirer;
   }
   public void setEtirer(int etirer) {
      this.etirer = etirer;
   }
   public int getOrientation() {
      return this.orientation;
   }
   public void setOrientation(int orientation) {
      this.orientation = orientation;
   }
   // fin GETTERS SETTERS
}