| |
auteur :
Clément Cunin | La taille de l'écran est disponible grâce à la classe java.awt.Toolkit.
Dimension tailleEcran = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
int hauteur = (int)tailleEcran.getHeight();
int largeur = (int)tailleEcran.getWidth();
|
| |
auteur :
Clément Cunin | A partir du JDK 1.4 : Le JDK 1.4 offre une méthode de centrage automatique des fenêtres, plus besoin de faire cela à la main... La méthode setLocationRelativeTo(java.awt.Component) de la classe java.awt.Window permets de faire un centrage par rapport à un composant ou à l'écran.
Le centrage doit être effectué par rapport à un composant affiché au moment où l'on veut centrer notre fenêtre... Généralement juste avant de la rendre visible. (si le paramètre est null ou que le composant n'est pas affiché, le centrage est fait par rapport à l'écran.)
/** Centrage de la fenêtre par rapport à la fenêtre parente.
* S'il n'y a pas de fenêtre parente, on centre par rapport à l'écran
*/
maFenetre.setLocationRelativeTo(maFenetre.getParent());
/** ...puis on l'affiche */
maFrame.show();
JDK 1.3 et antérieurs : Aucune méthode ne fait cela automatiquement, mais il est très facile de positionner soit-même la fenêtre lors de l'initialisation.
/** Lecture de la taille de l'écran */
java.awt.Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
frame.pack();
/* la fenêtre prend sa taille... */
frame.setLocation(
(screenSize.width-frame.getWidth())/2,
(screenSize.height-frame.getHeight())/2
);
|
lien : Comment connaître la taille de l'écran ?
|
| |
auteur :
Johann Heymes | Centré autour de ses quatres composants voisins Réponse toute simple : en utilisant le LayoutManager approprié à ce cas de figure, à savoir java.awt.BorderLayout.
JPanel panel = new JPanel (new BorderLayout ());
panel.add (monComposant, BorderLayout.CENTER);
/** le deuxième paramètre de la méthode add n'est pas obligatoire,
* car il s'agit de la valeur par défaut
*/
N'oubliez pas que la caractéristique principale du BorderLayout est d'ajuster la dimension du composant à la place disponible.
Centré sur son conteneur (JPanel ) Là aussi c'est le choix du LayoutManager qui résout le problème, mais il est nécessaire d'en prendre un quelque peu plus compliqué : java.awt.GridBagLayout.
JPanel p = new JPanel (new GridBagLayout ());
p.add (composant,
new GridBagConstraints (0, 0, 1, 1, 0, 0,
GridBagConstraints.CENTER,
GridBagConstraints.CENTER,
new Insets (0,0,0,0), 0, 0));
|
| |
auteur :
Nourdine Falola | A l'aide des gestionnaires de mise en forme
Java propose un certain nombre gestionnaires de mise en forme, ou layout managers, qui permettent de placer les composants sans en indiquer la position précise (les coordonnées), mais la disposition souhaitée.
Les principaux gestionnaires sont :
Si l'on a besoin d'une mise en forme particulière, il est possible de créer des gestionnaires de mise en forme personnalisés.
En spécifiant les coordonnées
Il est possible de se passer des gestionnaires de mise en forme pour le placement des composants. Pour cela, on définit le gestionnaire de mise en forme du contenant à null, on ajoute le composant au contenant et on spécifie la position absolue et la taille voulue du composant :
setLayout(null);
JButton ok = new JButton("OK");
ok.setBounds(x,y,width,height);
|
| |
auteur :
Nourdine Falola | Ce gestionnaire aligne horizontalement les composants, en préservant la taille de ceux-ci, jusqu'à ce qu'il n'y ait plus de place. Lorsque la ligne est remplie, les composants suivant sont placés à la ligne suivante et ainsi de suite.
Par défaut les composants sont centrés horizontalement. Lorsque la taille du conteneur est modifiée, les composants sont réorganisés automatiquement.
FlowLayout est le gestionnaire de mise en forme par défaut des JPanel.
class FlowLayoutFrame extends JFrame
{
public FlowLayoutFrame ()
{
setTitle("FlowLayout Test");
setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
JPanel panel = new JPanel();
getContentPane().add(panel);
panel.add(new JButton("Bouton 1"));
panel.add(new JButton("Bouton 2"));
panel.add(new JButton("Bouton 3"));
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
static final int DEFAULT_WIDTH = 200;
static final int DEFAULT_HEIGHT = 150;
}
|
| |
auteur :
Nourdine Falola | Ce gestionnaire décompose le conteneur en 5 zones : Centre, Nord, Sud, Est, Ouest.
Si on ne précise pas la zone dans laquelle on veut placer le composant, celui-ci est placé au centre. Les composants en bordure sont placés en premier, puis l'espace restant est occupé par le composant central.
Ce gestionnaire modifie la taille des composants afin qu'ils prennent tout l'espace disponible. En cas de redimensionnement, seul le centre est redimensionné en hauteur ET en largeur.
BorderLayout est le gestionnaire de mise en forme par défaut des JFrame.
class BorderLayoutFrame extends JFrame
{
public BorderLayoutFrame ()
{
setTitle("BorderLayout Test");
setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
Container c = getContentPane();
c.add(makeLabel(" NORD "),BorderLayout.NORTH);
c.add(makeLabel(" SUD "),BorderLayout.SOUTH);
c.add(makeLabel(" EST "),BorderLayout.EAST);
c.add(makeLabel(" OUEST "),BorderLayout.WEST);
c.add(makeLabel(" CENTRE "),BorderLayout.CENTER);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
private JLabel makeLabel(String text)
{
JLabel label = new JLabel(text,JLabel.CENTER);
Border borderLine = BorderFactory.createLineBorder(Color.BLACK);
label.setBorder(borderLine);
return label;
}
static final int DEFAULT_WIDTH = 200;
static final int DEFAULT_HEIGHT = 150;
}
|
| |
auteur :
Nourdine Falola | Ce gestionnaire arrange les composants sur une grille dont on spécifie le nombre de cases horizontales et verticales.
Un composant est redimensionné afin de prendre tout l'espace de la cellule, et chaque cellule est de taille identique. Lorsque la fenêtre est redimensionnée, les cellules se partagent équitablement l'espace disponible. Les composants sont ajoutés ligne par ligne à partir de la cellule du coin supérieur gauche.
class GridLayoutFrame extends JFrame
{
public GridLayoutFrame ()
{
setTitle("GridLayout Test");
setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
setLayout(new GridLayout(2,3));
Container c = getContentPane();
c.add(new JButton("(1,1)"));
c.add(new JButton("(1,2)"));
c.add(new JButton("(1,3)"));
c.add(new JButton("(2,1)"));
c.add(new JButton("(2,2)"));
c.add(new JButton("(2,3)"));
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
static final int DEFAULT_WIDTH = 200;
static final int DEFAULT_HEIGHT = 150;
}
|
| |
auteur :
Nourdine Falola | Ce gestionnaire permet de placer les composants sur une même ligne ou une même colonne.
Comme pour les autres gestionnaires, on peut l'assigner comme gestionnaire du conteneur (JFrame, JPanel...). Cependant, il existe un conteneur "dédié", le Box, dont le gestionnaire par défaut est un BoxLayout.
Utiliser des Box nous permet d'avoir plusieurs BoxLayout dans un même conteneur (dans le JFrame par exemple).
Les composants sont insérés :
- de gauche à droite pour le BoxLayout horizontal
- de haut en bas pour le BoxLayout vertical
Par défaut, les composants sont collés les uns aux autres. Pour les espacer, il faut insérer des réserves entre les composants. Il en existe 3 types :
- le Strut, qui ajoute un espace mesuré en nombre de pixels. Le Strut est unidimensionnel : il existe un Strut horizontal et un Strut vertical
- le RigidArea, qui est équivalent à un couple de Strut horizontal/vertical
- le Glue, qui repousse les 2 composants voisins aussi loin que possible l'un de l'autre.
Stratégie de mise en forme :
- Le BoxLayout horizontal calcul la taille maximale du plus haut composant et tente d'agrandir tous les autres composants à la même hauteur. Les composants qui n'ont pu atteindre cette hauteur sont alignés (appel à getAlignementY()). Les largeurs préférées des composants sont additionnées. Si la largeur du BoxLayout ne correspond pas à cette somme, la taille des composants est ajustée dans les limites des tailles min et max. Si le Box est trop petit, des composants ne seront pas affichés.
- stratégie analogue pour le BoxLayout vertical.
class BoxLayoutFrame extends JFrame
{
public BoxLayoutFrame ()
{
setTitle("BoxLayout Test");
setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
JLabel nomLabel = new JLabel("Nom : ");
JTextField nomText = new JTextField(10);
nomText.setMaximumSize(nomText.getPreferredSize());
Box hBox1 = Box.createHorizontalBox();
hBox1.add(nomLabel);
hBox1.add(Box.createHorizontalStrut(5));
hBox1.add(nomText);
JLabel prenomLabel = new JLabel("Prénom : ");
JTextField prenomText = new JTextField(10);
prenomText.setMaximumSize(prenomText.getPreferredSize());
Box hBox2 = Box.createHorizontalBox();
hBox2.add(prenomLabel);
hBox2.add(Box.createHorizontalStrut(5));
hBox2.add(prenomText);
Box hBox3 = Box.createHorizontalBox();
hBox3.add(new JButton("OK"));
hBox3.add(Box.createGlue());
hBox3.add(new JButton("Annuler"));
Box vBox = Box.createVerticalBox();
vBox.add(hBox1);
vBox.add(hBox2);
vBox.add(Box.createGlue());
vBox.add(hBox3);
add(vBox,BorderLayout.CENTER);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
static final int DEFAULT_WIDTH = 200;
static final int DEFAULT_HEIGHT = 150;
}
 |
| |
auteur :
Clément Cunin | Le passage en plein écran est très utile pour la programmation de jeu, mais aussi dans les applications à titre ponctuel pour faire une prévisualisation d'impression, d'image, pour faire un diaporama ou autres ...
Passage en plein écran : Le passage de l'affichage en plein écran est une nouvelle fonctionnalité de j2se 1.4. La classe java.awt.GraphicsEnvironment permet de connaître la liste des écrans. Il est fortement recommandée de vérifier que le plein écran est supporté ; si ce n'est pas le cas la fenêtre est redimensionnée pour prendre tout l'écran mais elle n'a pas l'exclusivité de l'affichage.
GraphicsDevice myDevice = java.awt.GraphicsEnvironment.
getLocalGraphicsEnvironment().getDefaultScreenDevice();
Window myWindow;
if( myDevice.isFullScreenSupported() ) {
try {
myDevice.setFullScreenWindow(myWindow);
/** ... */
} finally {
myDevice.setFullScreenWindow(null);
}
} else {
System.err.println("Plein écran non supporté");
}
Changement de résolution : La diminution de la résolution est particulièrement conseillée pour augmenter la performance d'affichage ( moins il y a de pixels, mieux c'est ). Une configuration est définie par une instance de java.awt.DisplayMode. Exemple de code :
myDevice.setDisplayMode(new DisplayMode(
800,
600,
DisplayMode.BIT_DEPTH_MULTI,
DisplayMode.REFRESH_RATE_UNKNOWN
));
Avant de commencer : Avant de vous embarquer dans la réalisation d'un super jeu en plein écran, je vous conseille de vous renseigner un minimum sur les techniques d'optimisation et d'accélération de l'affichage (vois lien ci-dessous).
Et les applets ? Les applets sont autorisées à passer en affichage plein écran seulement si l'utilisateur a la permission fullScreenExclusive.
|
lien : http://java.sun.com/docs/books/tutorial/extra/fullscreen/
lien : Comment accélérer le rendu graphique de mon dessin ?
lien : Comment utiliser le double-buffering software ?
|
| |
auteur :
Clément Cunin | L'icone d'une application apparaît à divers endroits en fonction du système d'exploitation. Sous windows, on la retrouve en haut à gauche de la fenêtre, et dans la barre des taches. Par défaut, il s'agit de la tasse de café de Java. Il est très facile de la personnaliser en utilisant la méthode setIconImage(java.awt.Image) des classes javax.swing.JFrame et javax.swing.JDialog.
Image icone = Toolkit.getDefaultToolkit().getImage("./monImage.jpg");
maFenetre.setIconImage(icone);
Si l'image n'apparaît pas, c'est certainement que le paramètre image a une valeur 'null'.
|
lien : Comment accéder à une image ?
|
| |
auteur :
Clément Cunin | Lorsque l'on affiche une fenêtre à l'écran, la machine virtuelle alloue la mémoire et les ressources systèmes nécessaires à la création de l'image de cette fenêtre à l'écran. Les méthodes hide() et dispose() font tous les deux disparaître la fenêtre de l'écran ; en revanche, elles diffèrent par leur action sur la mémoire.
Cacher une fenêtre avec hide() : La méthode hide() se contente de masquer la fenêtre, les ressources nécessaires à son affichage sont conservées. La fenêtre est donc prête à être réaffichée. C'est une bonne idée de cacher les fenêtres qui sont utilisées régulièrement par l'application, leur réaffichage est plus rapide.
Détruire une fenêtre avec dispose() : La méthode dispose() restitue les ressources au système. Les ressources libérées ne concernent que les objets utilisés pour la construction de l'image, les différents composants que vous avez placés dans la fenêtre restent en mémoire comme n'importe quel autre objet. Même après avoir été détruit, on peut toujours utiliser la méthode show() pour réafficher la fenêtre (de nouvelles ressources seront alors allouées). C'est donc une très bonne idée de détruire les fenêtres lorsque vous n'en avez plus besoin.
Note : Tant qu'une fenêtre n'est pas détruite, elle ne peut pas être collectée par le ramasse miettes.
|
lien : Comment fermer une fenêtre lors d'un clic sur la croix en haut à droite ?
|
| |
auteur :
Clément Cunin | AWT : Lorsque l'on créer une fenêtre avec AWT, aucune action n'est associée à la commande de fermeture de cette fenêtre. Nous allons donc en associer une.
maFenetre.addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosing(java.awt.event.WindowEvent evt) {
hide();
}
} );
SWING : Par défaut, les fenêtres Swing sont cachées lorsque l'utilisateur clic sur la croix. Cette action par défaut peut facilement être remplacée avec setDefaultCloseOperation(int).
maFenetre.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
Liste des opérations définies par défaut:- DO_NOTHING_ON_CLOSE - Ne fait aucune action par défaut.
- HIDE_ON_CLOSE - Cache la fenêtre.
- DISPOSE_ON_CLOSE - Détruit la fenêtre.
- EXIT_ON_CLOSE - Quitte l'application.
Note : La solution utilisée avec AWT reste valable avec Swing, elle permet d'effectuer des traitements plus complexez en parallèle du traitement par défaut.
|
lien : Quelle différence entre cacher et détruire une fenêtre ?
|
| |
auteur :
Clément Cunin | Frame & JFrame (JDK1.3 et précédants) Les classes java.awt.Frame et javax.swing.JFrame correspondent aux fenêtres du système d'exploitation, il n'est pas possible de changer l'apparence de la barre des titres ni des boutons de fermeture et d'agrandissement.
Window & JWindow Contrairement aux 2 classes précédentes, java.awt.Window et javax.swing.JWindow définissent une fenêtre sans aucun cadre ni barre de titre. Elles sont donc idéales pour faire des écrans de démarrage ou des interfaces personnalisées.
A partir du JDK1.4 Le jdk1.4 définit une nouvelle méthode setUndecorated(boolean) pour les classes java.awt.Frame et java.awt.Dialog. Attention : cette méthode doit être appelée avant le premier affichage de la fenêtre à l'écran.
|
| |
auteur :
Ioan Calapodescu | Depuis J2SE 1.4
Pour maximiser ou iconifier votre fenêtre, vous pouvez utiliser la méthode setExtendedState de la classe Frame. Par exemple, pour maximiser de tous les côtés votre fenêtre, vous pouvez faire comme ceci :
JFrame frame = ... ;
frame.setExtendedState(JFrame.MAXIMIZED_BOTH);
Les options possibles sont :
- NORMAL : aucun état spécial
- ICONIFIED : la fenêtre est iconifiée
- MAXIMIZED_HORIZ : la fenêtre occupe le maximum de place horizontalement
- MAXIMIZED_VERT : la fenêtre occupe le maximum de place verticalement
- MAXIMIZED_BOTH : la fenêtre est maximisée de tous côtés
Avant J2SE 1.4
Vous pouvez utiliser la méthode setState de la classe Frame. Son utilisation est la même que pour setExtendedState, à la différence qu'il n'existe pas de paramètre permettant de maximiser. Si vous voulez tout de même avoir l'impression que votre fenêtre est maximisée, c'est à dire qu'elle prenne toute la place disponible à l'écran, tout en gardant visible la barre d'outils, vous pouvez faire comme ceci :
public void maximiser(Frame frame){
Toolkit kit = Toolkit.getDefaultToolkit();
Insets insets = kit.getScreenInsets(frame.getGraphicsConfiguration());
Dimension screen = kit.getScreenSize();
int w = (int)(screen.getWidth()-insets.left-insets.right);
int h = (int)(screen.getHeight()-insets.top-insets.bottom);
int x = (int)(insets.left);
int y = (int)(insets.top);
Dimension dimension = new Dimension(w,h);
frame.setSize(dimension);
frame.setLocation(x,y);
}
|
| |
auteur :
Ioan Calapodescu | Pour garder une fenêtre toujours au premier plan, il faut utiliser la méthode setAlwaysOnTop de la classe Window.
JFrame frame = new JFrame("Titre");
frame.setSize(200,200);
frame.setAlwaysOnTop(true);
frame.setVisible(true);
Si il existe plusieurs fenêtres ayant cette propriété à true, le comportement sera défini par le système. De plus, cette méthode est susceptible de lever une SecurityException.
Attention : Cette fonctionnalité n'est disponible dans l'API standard que depuis la version 1.5 de J2SE. Pour les versions précédentes, la seule possibilité est de passer par JNI et des API natives.
|
Consultez les autres F.A.Q's
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre intellectuelle protégée par les droits d'auteurs.
Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs :
- Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement :
"Ce document issu de http://www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page tant que cette note apparaît clairement".
- Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC. Aucune reproduction, ne peux en être faite sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.
|
|
|
