Linelayout : layout manager pour placement sur un axe

Soyez le premier à donner votre avis sur cette source.

Vue 8 121 fois - Téléchargée 360 fois

Description

Ce Layout Manager permet de placer les composants qu'on ajoute à un conteneur selon un axe (horizontal ou vertical).
Il permet de définir les modalités d'étirement c'est à dire que les composants vont s'étirer suivant un axe, les deux ou aucun.
Il permet de définir les modalités d'alignement pour l'axe vertical (top, center ou bottom) ET pour l'axe horizontal (left, center, right)
Il permet de définir un espacement entre les différents composants.

Pour ne pas vous mentir je suis parti du VerticalLayout de JHelp, je le trouvais très bien mais assez limité.
Je l'ai étoffé (quelques peu) pour pouvoir l'adapter aux configurations voulues !

Source / Exemple :

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
}

Conclusion :

Je l'ai testé sur pas mal de configuration, pour les besoins de mon application. Au total on peu avoir plus de 128 possibilités de placement. Je ne les ai pas toutes testées. Si toutefois vous rencontrez des problèmes ou avez des soucis, n'hésitez pas à me contacter.

Vous pouvez le tester avec ceci :
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

/*
  • Created on 7 févr. 2006
  • /


/**
  • @author nico
  • /

public class Test {

public static void testThis(LineLayout ll){
String stringOrientation = ll.getOrientation() == LineLayout.VERTICAL ? "VERTICAL" : "HORIZONTAL";

JFrame frame = new JFrame(stringOrientation);

JPanel panelConteneur = new JPanel();
panelConteneur.setLayout(ll);

for(int i = 0; i <= 7; i++){
JButton bouton = new JButton(i + "");
panelConteneur.add(bouton);
}


frame.setContentPane(panelConteneur);
frame.pack();
frame.setVisible(true);
}

public static void main(String[] args) {

LineLayout ll = new LineLayout(LineLayout.VERTICAL, LineLayout.VERTICAL,
LineLayout.CENTER, LineLayout.NONE, 5, 5);


testThis(ll);


/*
for (int orientation = 0; orientation < 2; orientation++) {
for (int etirer = 0; etirer < 5; etirer++) {
for (int alignementHorizontal = 0; alignementHorizontal < 4; alignementHorizontal++) {
for (int alignementVertical = 0; alignementVertical < 5; alignementVertical++) {
LineLayout ll = new LineLayout(orientation, etirer, alignementHorizontal,
alignementVertical, 5, 5);


testThis(ll);

if (alignementVertical == 1)
alignementVertical += 2;
}
}

}
}*/
}
}

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
1
Date d'inscription
jeudi 29 mai 2003
Statut
Membre
Dernière intervention
10 juillet 2007

Salut, effectivement très pratique ton layout merci.
Par contre, il y a un petit bug en ligne 262, qui apparait en orientation Horizontale et alignement à droite
donc faut remplacer la ligne suivante:
nouvelX = parent.getWidth() - parent.getComponent(i).getWidth() - espaceHorizontal;
par celle-ci:
nouvelX = parent.getWidth() - x - parent.getComponent(i).getWidth() - espaceHorizontal;
Messages postés
3
Date d'inscription
samedi 26 mars 2005
Statut
Membre
Dernière intervention
14 juin 2006

Merci beaucoup pour ton code, ca me permet de faire exactement ce que je voulais faire, cad une présentation verticale d'une succession de JLabel dans un JPanel ^^

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.