Linelayout : layout manager pour placement sur un axe
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 !
Vous pouvez le tester avec ceci :
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
/*
/**
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;
}
}
}
}*/
}
}
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;
}
}
}
}*/
}
}
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.