Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

LINELAYOUT : LAYOUT MANAGER POUR PLACEMENT SUR UN AXE


Information sur la source

Catégorie :Api Classé sous : layout, emplacement, placer, horizontal, vertical Niveau : Débutant Date de création : 08/02/2006 Vu / téléchargé: 4 227 / 260

Note :
9 / 10 - par 1 personne
9,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10

Commentaire sur cette source (2)
Ajouter un commentaire et/ou une note

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

  • 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
  • }
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;
               }
            }

         }
      }*/
   }
}

 

Fichier Zip

Pour les "Membres Club", vous pouvez télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip

Commentaires et avis

signaler à un administrateur
Commentaire de Thiouwz03 le 14/06/2006 11:22:41

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 ^^

signaler à un administrateur
Commentaire de leautiste le 10/07/2007 12:23:57

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;

Ajouter un commentaire

Discussions en rapport avec ce code source dans le forum

[swing-layout]placer un composant au CENTRE d'un autre [ par vychnou ] Bonjour à tous. J'ai un problème tout bête: Un panel s'affiche en plein écran. Dans ce panel, on charge un composant (qui a une taille fixée inférieur Se placer à un time code donné dans une vidéo [ par pedrolito2000 ] Bonjour,J'aimerais savoir comment on fait pour se placer à un timecode donné dans une vidéo (i.e. on entre un timecode dans un cadre et la vidéo se pl texte en vertical [ par lafolle24320 ] Bonjour, je voudrais faire un label en java mais écri à la vertical. quelqu'un saurai t il comment tourner mon label? merci beaucoup par avance lafo Pb layout [ par jesaipa_1 ] Slt, je voulais savoir s'il y a un moyen que l'on change la propriété du FlowLayout car je voudrais aligné a gauche les composants ajouté dans le pane affichage d'un container dans un autre en fct du menu [ par bmikl59 ] Bonjour,j'ai des probleme avec les layout de mes container...je m'expliqueJ'ai crée une classe qui dessine une fentre principale :public</f Fixer une toolbar et placer un JLabel [ par yannus83 ] Bonjour,Nouveau problème :Comment fixer une toolbar en haut de l'écran et qu'elle prenne toute la largeur j'ai utilisé : (pane.add(toolbar,BorderLayou interface graphique [ par gadour_esz ] salut,voila mon code java  dont je l'avais préparé avec l'éditeur NetBeanspublic class Fenetre5 extends javax.swing.JFrame {        /** Creates new fo probleme avec le layout null [ par anisj1m ] bonjour;pour ma boite de dialogue je l'ai decompose en 3 partie par border layout (north,center et south) alors north et south sont des panels de type Layout Manager [ par mtniang ] Bonjour.Je fais un exposé sur  les gestionnaires de disposition en java .Et je voudrai savoir avec quelle version de JDBC les layout manager ont comme Layout Manager [ par mtniang ] Bonjour.Je voudrai savoir avec quelle version de JDK les layout manager ont commencé.Merci de votre aide


Nos sponsors

Sondage...

CalendriCode

Décembre 2008
LMMJVSD
1234567
891011121314
15161718192021
22232425262728
293031    

Consulter la suite du CalendriCode

Téléchargements



Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel BAÏSE, Merci à Vincent pour ses précieux conseils
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés
Temps d'éxécution de la page : 0,390 sec

Google Coop CodeS-SourceS Google Coop CodeS-SourceS


Certaines images présentes sur le site (notament certains avatars) sont issues des collections IconShock, donc si vous souhaitez utiliser ces icons vous devez les acheter, ne les copiez pas et ne utilisez pas dans vos sites et applications sans les avoir commandé.