Comment centrer une fenêtre en Java?
https://stackoverflow.com/questions/144892
-
02-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Quel est le moyen le plus simple de centrer un java.awt.Window , tel qu'un JFrame ou un JDialog ?
La solution
De ce lien
Si vous utilisez Java 1.4 ou plus récent, vous pouvez utiliser la méthode simple setLocationRelativeTo (null) sur le boîte de dialogue, cadre ou fenêtre au centre il.
Autres conseils
Ceci devrait fonctionner dans toutes les versions de Java
public static void centreWindow(Window frame) {
Dimension dimension = Toolkit.getDefaultToolkit().getScreenSize();
int x = (int) ((dimension.getWidth() - frame.getWidth()) / 2);
int y = (int) ((dimension.getHeight() - frame.getHeight()) / 2);
frame.setLocation(x, y);
}
Notez que les techniques setLocationRelativeTo (null) et Tookit.getDefaultToolkit (). getScreenSize () ne fonctionnent que pour le moniteur principal. Si vous êtes dans un environnement multi-moniteur, vous devrez peut-être obtenir des informations sur le moniteur spécifique sur lequel se trouve la fenêtre avant de faire ce type de calcul.
Parfois important, parfois pas ...
Voir javadocs GraphicsEnvironment pour plus d'informations. infos sur comment l'obtenir.
setLocationRelativeTo (null) doit être appelé après l'utilisation de setSize (x, y) ou de pack ().
Sous Linux, le code
setLocationRelativeTo(null)
Placez ma fenêtre dans un emplacement aléatoire chaque fois que je l’a lancée, dans un environnement à écrans multiples. Et le code
setLocation((Toolkit.getDefaultToolkit().getScreenSize().width - getSize().width) / 2, (Toolkit.getDefaultToolkit().getScreenSize().height - getSize().height) / 2);
" couper " la fenêtre en deux avec le placer au centre exact, ce qui est entre mes deux écrans. J'ai utilisé la méthode suivante pour le centrer:
private void setWindowPosition(JFrame window, int screen)
{
GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice[] allDevices = env.getScreenDevices();
int topLeftX, topLeftY, screenX, screenY, windowPosX, windowPosY;
if (screen < allDevices.length && screen > -1)
{
topLeftX = allDevices[screen].getDefaultConfiguration().getBounds().x;
topLeftY = allDevices[screen].getDefaultConfiguration().getBounds().y;
screenX = allDevices[screen].getDefaultConfiguration().getBounds().width;
screenY = allDevices[screen].getDefaultConfiguration().getBounds().height;
}
else
{
topLeftX = allDevices[0].getDefaultConfiguration().getBounds().x;
topLeftY = allDevices[0].getDefaultConfiguration().getBounds().y;
screenX = allDevices[0].getDefaultConfiguration().getBounds().width;
screenY = allDevices[0].getDefaultConfiguration().getBounds().height;
}
windowPosX = ((screenX - window.getWidth()) / 2) + topLeftX;
windowPosY = ((screenY - window.getHeight()) / 2) + topLeftY;
window.setLocation(windowPosX, windowPosY);
}
Fait apparaître la fenêtre au centre du premier affichage. Ce n'est probablement pas la solution la plus simple.
Fonctionne correctement sous Linux, Windows et Mac.
J'ai enfin réussi à faire fonctionner ce groupe de codes dans NetBeans à l'aide de formulaires d'interface graphique Swing afin de centrer le principal jFrame:
package my.SampleUIdemo;
import java.awt.*;
public class classSampleUIdemo extends javax.swing.JFrame {
///
public classSampleUIdemo() {
initComponents();
CenteredFrame(this); // <--- Here ya go.
}
// ...
// void main() and other public method declarations here...
/// modular approach
public void CenteredFrame(javax.swing.JFrame objFrame){
Dimension objDimension = Toolkit.getDefaultToolkit().getScreenSize();
int iCoordX = (objDimension.width - objFrame.getWidth()) / 2;
int iCoordY = (objDimension.height - objFrame.getHeight()) / 2;
objFrame.setLocation(iCoordX, iCoordY);
}
}
OU
package my.SampleUIdemo;
import java.awt.*;
public class classSampleUIdemo extends javax.swing.JFrame {
///
public classSampleUIdemo() {
initComponents();
//------>> Insert your code here to center main jFrame.
Dimension objDimension = Toolkit.getDefaultToolkit().getScreenSize();
int iCoordX = (objDimension.width - this.getWidth()) / 2;
int iCoordY = (objDimension.height - this.getHeight()) / 2;
this.setLocation(iCoordX, iCoordY);
//------>>
}
// ...
// void main() and other public method declarations here...
}
OU
package my.SampleUIdemo;
import java.awt.*;
public class classSampleUIdemo extends javax.swing.JFrame {
///
public classSampleUIdemo() {
initComponents();
this.setLocationRelativeTo(null); // <<--- plain and simple
}
// ...
// void main() and other public method declarations here...
}
Ce qui suit ne fonctionne pas pour JDK 1.7.0.07:
frame.setLocationRelativeTo(null);
Cela place le coin supérieur gauche au centre, ce qui est différent du centrage de la fenêtre. L’autre ne fonctionne pas non plus, impliquant frame.getSize () et dimension.getSize ():
Dimension dimension = Toolkit.getDefaultToolkit().getScreenSize();
int x = (int) ((dimension.getWidth() - frame.getWidth()) / 2);
int y = (int) ((dimension.getHeight() - frame.getHeight()) / 2);
frame.setLocation(x, y);
La méthode getSize () est héritée de la classe Component. Par conséquent, frame.getSize renvoie également la taille de la fenêtre. Ainsi, en soustrayant la moitié des dimensions verticale et horizontale des dimensions verticale et horizontale, pour trouver les coordonnées x, y de l'emplacement du coin supérieur gauche, vous obtenez l'emplacement du point central qui finit également par centrer la fenêtre. Cependant, la première ligne du code ci-dessus est utile, "Dimension ...". Faites ceci pour le centrer:
Dimension dimension = Toolkit.getDefaultToolkit().getScreenSize();
JLabel emptyLabel = new JLabel("");
emptyLabel.setPreferredSize(new Dimension( (int)dimension.getWidth() / 2, (int)dimension.getHeight()/2 ));
frame.getContentPane().add(emptyLabel, BorderLayout.CENTER);
frame.setLocation((int)dimension.getWidth()/4, (int)dimension.getHeight()/4);
Le JLabel définit la taille de l'écran. Il est disponible dans FrameDemo.java dans les didacticiels Java du site Oracle / Sun. Je l'ai réglé à la moitié de la hauteur / largeur de la taille de l'écran. Ensuite, je l'ai centré en plaçant le coin supérieur gauche à 1/4 de la dimension de la taille de l'écran en partant de la gauche et 1/4 de la dimension de la taille de l'écran à partir du haut. Vous pouvez utiliser un concept similaire.
ci-dessous est le code permettant d’afficher un cadre en haut au centre de la fenêtre existante.
public class SwingContainerDemo {
private JFrame mainFrame;
private JPanel controlPanel;
private JLabel msglabel;
Frame.setLayout(new FlowLayout());
mainFrame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent windowEvent){
System.exit(0);
}
});
//headerLabel = new JLabel("", JLabel.CENTER);
/* statusLabel = new JLabel("",JLabel.CENTER);
statusLabel.setSize(350,100);
*/ msglabel = new JLabel("Welcome to TutorialsPoint SWING Tutorial.", JLabel.CENTER);
controlPanel = new JPanel();
controlPanel.setLayout(new FlowLayout());
//mainFrame.add(headerLabel);
mainFrame.add(controlPanel);
// mainFrame.add(statusLabel);
mainFrame.setUndecorated(true);
mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
mainFrame.getRootPane().setWindowDecorationStyle(JRootPane.NONE);
mainFrame.setVisible(true);
centreWindow(mainFrame);
}
public static void centreWindow(Window frame) {
Dimension dimension = Toolkit.getDefaultToolkit().getScreenSize();
int x = (int) ((dimension.getWidth() - frame.getWidth()) / 2);
int y = (int) ((dimension.getHeight() - frame.getHeight()) / 2);
frame.setLocation(x, 0);
}
public void showJFrameDemo(){
/* headerLabel.setText("Container in action: JFrame"); */
final JFrame frame = new JFrame();
frame.setSize(300, 300);
frame.setLayout(new FlowLayout());
frame.add(msglabel);
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent windowEvent){
frame.dispose();
}
});
JButton okButton = new JButton("Capture");
okButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
// statusLabel.setText("A Frame shown to the user.");
// frame.setVisible(true);
mainFrame.setState(Frame.ICONIFIED);
Robot robot = null;
try {
robot = new Robot();
} catch (AWTException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
final Dimension screenSize = Toolkit.getDefaultToolkit().
getScreenSize();
final BufferedImage screen = robot.createScreenCapture(
new Rectangle(screenSize));
SwingUtilities.invokeLater(new Runnable() {
public void run() {
new ScreenCaptureRectangle(screen);
}
});
mainFrame.setState(Frame.NORMAL);
}
});
controlPanel.add(okButton);
mainFrame.setVisible(true);
} public statique void main (String [] args) lève Exception {
new SwingContainerDemo().showJFrameDemo();
}
Voici l'extrait de l'extrait de code ci-dessus: 
frame.setLocationRelativeTo (null);
Exemple complet:
public class BorderLayoutPanel {
private JFrame mainFrame;
private JButton btnLeft, btnRight, btnTop, btnBottom, btnCenter;
public BorderLayoutPanel() {
mainFrame = new JFrame("Border Layout Example");
btnLeft = new JButton("LEFT");
btnRight = new JButton("RIGHT");
btnTop = new JButton("TOP");
btnBottom = new JButton("BOTTOM");
btnCenter = new JButton("CENTER");
}
public void SetLayout() {
mainFrame.add(btnTop, BorderLayout.NORTH);
mainFrame.add(btnBottom, BorderLayout.SOUTH);
mainFrame.add(btnLeft, BorderLayout.EAST);
mainFrame.add(btnRight, BorderLayout.WEST);
mainFrame.add(btnCenter, BorderLayout.CENTER);
// mainFrame.setSize(200, 200);
// or
mainFrame.pack();
mainFrame.setVisible(true);
//take up the default look and feel specified by windows themes
mainFrame.setDefaultLookAndFeelDecorated(true);
//make the window startup position be centered
mainFrame.setLocationRelativeTo(null);
mainFrame.setDefaultCloseOperation(mainFrame.EXIT_ON_CLOSE);
}
}
Il y a quelque chose de vraiment simple que vous pouvez oublier après avoir essayé de centrer la fenêtre en utilisant setLocationRelativeTo (null) ou setLocation (x, y) et le résultat finit par être un peu excentré.
Assurez-vous d'utiliser l'une de ces méthodes après appelant pack () , car vous utiliserez les dimensions suivantes: la fenêtre elle-même pour calculer où la placer à l'écran. Jusqu'à ce que pack () soit appelé, les dimensions ne sont pas ce que l'on pourrait penser, ce qui jette les calculs pour centrer la fenêtre. J'espère que cela vous aidera.
Exemple: Dans myWindow (), ligne 3, vous trouverez le code nécessaire pour définir la fenêtre au centre de l'écran.
JFrame window;
public myWindow() {
window = new JFrame();
window.setSize(1200,800);
window.setLocationRelativeTo(null); // this line set the window in the center of thr screen
window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
window.getContentPane().setBackground(Color.BLACK);
window.setLayout(null); // disable the default layout to use custom one.
window.setVisible(true); // to show the window on the screen.
}
En réalité, les éléments .getHeight () et getwidth () ne renvoient pas de valeurs, vérifiez-les par System.out.println (frame.getHeight ()); met directement les valeurs pour width et height, alors cela fonctionnera très bien au centre. par exemple: comme ci-dessous
Dimension dimension = Toolkit.getDefaultToolkit().getScreenSize();
int x=(int)((dimension.getWidth() - 450)/2);
int y=(int)((dimension.getHeight() - 450)/2);
jf.setLocation(x, y);
les deux 450 est ma hauteur de cadre n hauteur
public class SwingExample implements Runnable {
@Override
public void run() {
// Create the window
final JFrame f = new JFrame("Hello, World!");
SwingExample.centerWindow(f);
f.setPreferredSize(new Dimension(500, 250));
f.setMaximumSize(new Dimension(10000, 200));
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public static void centerWindow(JFrame frame) {
Insets insets = frame.getInsets();
frame.setSize(new Dimension(insets.left + insets.right + 500, insets.top + insets.bottom + 250));
frame.setVisible(true);
frame.setResizable(false);
Dimension dimension = Toolkit.getDefaultToolkit().getScreenSize();
int x = (int) ((dimension.getWidth() - frame.getWidth()) / 2);
int y = (int) ((dimension.getHeight() - frame.getHeight()) / 2);
frame.setLocation(x, y);
}
}
Le code suivant centre la Fenêtre au centre du moniteur actuel (c'est-à-dire où se trouve le pointeur de la souris).
public static final void centerWindow(final Window window) {
GraphicsDevice screen = MouseInfo.getPointerInfo().getDevice();
Rectangle r = screen.getDefaultConfiguration().getBounds();
int x = (r.width - window.getWidth()) / 2 + r.x;
int y = (r.height - window.getHeight()) / 2 + r.y;
window.setLocation(x, y);
}
Vous pouvez aussi essayer ceci.
Frame frame = new Frame("Centered Frame");
Dimension dimemsion = Toolkit.getDefaultToolkit().getScreenSize();
frame.setLocation(dimemsion.width/2-frame.getSize().width/2, dimemsion.height/2-frame.getSize().height/2);
