Partage

Problème de taille jframe

Sujet résolu

19 septembre 2011 à 16:40:27

Bonjour, j'ai encore un petit problème avec mon jeu de la vie, mais cette fois c'est ma JFrame qui embête, quand je lui donne une taille, cela prend aussi en compte la taille de la barre de titres, or si je veux que mon application aie la même apparence sur tous les systèmes ça va être problématique. Voici mon code:

public class GameOfLife {
    public static void main(String[] args) throws InterruptedException {
        Grid grid = new Grid();
        Render render = new Render(grid);
        
        JFrame window = new JFrame(); 
        window.setSize((grid.getSizeX()*render.getCellPixSize())+1, (grid.getSizeY()*render.getCellPixSize()) + 23 /*Taille du haut de la fenêtre OSX*/);
        window.setTitle("Game Of Life by Ludavid21");
        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        window.setContentPane(render);
        window.setVisible(true);
        
        while(window.isVisible()) {
            Thread.sleep(100);
            grid.tick();
            window.setContentPane(render); 
        } 
    }
}

La taille de la fenêtre est donnée suivant la taille des pixels et la taille de la grille, mais je suis obligé de rajouter 23 pixels pour la taille de la barre des titres. Il y aurait un moyen simple et portable d'éviter ça? Merci d'avance.

P.S. Oui je sais ma boucle principale est moche avec le sleep "^^ Je changerais après.

Ludavid21

20 septembre 2011 à 22:07:17

Ludavid21

22 septembre 2011 à 16:08:32

Ludavid21

23 septembre 2011 à 17:15:40

Ludavid21

24 septembre 2011 à 21:57:15

Up...

Ludavid21

26 septembre 2011 à 17:57:50

Moukett

26 septembre 2011 à 19:29:41

Salut.

Une bonne façon de faire est de définir la taille du contentPane de ta JFrame, et non directement de la JFrame. Dans ton cas c'est render.
Après la ligne window.setContentPane(render);
il te suffit d'ajouter la ligne window.pack();
et les dimensions de ta JFrame s'adapteront automatiquement à son contentPane.

Ludavid21

28 septembre 2011 à 15:39:13

Merci mais quand je rajoute ta ligne j'ai ça:

Image utilisateur

alors qu'avant j'avais:

Image utilisateur

Mercury

28 septembre 2011 à 17:00:00

Bonjour,

Dans la plupart des cas, il faut éviter de modifier les dimensions d'une JFrame directement. Les layouts permettent à la fenêtre de se redimensionner en fonction de son contenu.

Exemple :

public class NewJFrame extends javax.swing.JFrame {

    public NewJFrame() {
        Container contentPane = this.getContentPane();
        contentPane.setLayout(new BorderLayout());
        JPanel scene = new JPanel(null);
        scene.setPreferredSize(new Dimension(500,500));
        contentPane.add(scene);
        pack();
    }

}

Ici, le panel principal fera toujours 500x500 quel que soit le système, les barres de menus et tout ce qu'on veut mettre autour.

Moukett

28 septembre 2011 à 19:05:21

Ce qu'il te manque pour que ça marche c'est de définir les dimensions de ton render.

Ludavid21

28 septembre 2011 à 20:17:20

Merci =)

tylrgsen

29 septembre 2011 à 19:53:42

Je serais curieux de voir les sources de ton jeu de la vie...
Je me suis amusé à voir ce que je pouvais faire en 1h max, et j'en avais codé un petit avant hier soir, sans avoir lu ton post malheureusement(car j'aurais pu y répondre).
J'ai juste rajouté une ou deux fonctions depuis...

En fait, ce qui m'intéresse, ça serait de voir comment tu en as conçu la structure et les performances...

Ludavid21

29 septembre 2011 à 21:36:41

C'est pas terriblement optimisé, mais si tu veux voilà les sources. Comme j'ai commencer à implémenter des nouveautés, il y a peut-être des bouts de code qui ne servent encore à rien. Et comme je débute un peu, je pense que tu trouvera pas mal de mauvaises choses à pas faire

GameOfLife.java (main class):

package Ludavid21.Games;

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Dimension;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class GameOfLife {
    public static void main(String[] args) throws InterruptedException {
        Grid grid = new Grid();
        Render render = new Render(grid, false);
        
        JFrame window = new JFrame();
        Container contentPane = window.getContentPane();
        contentPane.setLayout(new BorderLayout());
        JPanel scene = new JPanel(null);
        scene.setPreferredSize(new Dimension((grid.getSizeX()*render.getCellPixSize())+1, (grid.getSizeY()*render.getCellPixSize())));
        window.setTitle("Game Of Life by Ludavid21");
        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        contentPane.add(scene);
        window.pack();
        window.setContentPane(render);
        window.setVisible(true);
        
        while(window.isVisible()) {
            Thread.sleep(200);
            grid.tick();
            window.setContentPane(render); 
        } 
    }
}

Render.java

package Ludavid21.Games;

import javax.swing.JPanel;
import java.awt.Graphics;

public class Render extends JPanel {
    
    int cellPixSize;
    Grid grid;
    boolean printGrid;
    
    public Render(Grid g, boolean prGr) {
        grid = g;
        cellPixSize = 10;
        printGrid = prGr;
        
    }
    
    public int getCellPixSize () {
        return cellPixSize;
    }
    
    
    public void paintComponent(Graphics g) {
        int[][] tempGrid = grid.getGrid();
        
        for(int i = 0 ; i < grid.getSizeY() ; i++) {
            for(int j = 0 ; j < grid.getSizeX() ; j++) {
                switch(tempGrid[i][j]) {
                    case 1:
                        g.fillRect((j*cellPixSize), (i*cellPixSize), cellPixSize, cellPixSize);
                        break;
                    default:
                        if(printGrid) g.drawRect((j*cellPixSize), (i*cellPixSize), cellPixSize, cellPixSize);
                        break;
                }
            }  
        }
    }
}

Grid.java

package Ludavid21.Games;



public class Grid {
    private int sizeX, sizeY;
    private int[][] grid;
    
    
    public Grid() {
        sizeX = 40; // Largeur
        sizeY = 20; // Hauteur
                         //X 0,1,2,3,4,5,6,7,8,9
        grid = new int[][] {{0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                            {0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0},
                            {0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0},
                            {0,0,0,0,1,0,0,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0},
                            {0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                            {0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0},
                            {0,0,0,0,1,0,0,0,0,1,0,0,1,1,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0},
                            {0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0},
                            {0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                            {0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                            {0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                            {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                            {0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                            {0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                            {0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                            {0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                            {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                            {0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                            {0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                            {0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                            
                            };
        
    
    }

    
    public int getNeighbors(int posX, int posY) {
        
        int neighbors = 0;
        
        for(int i = -1 ; i <= 1 ; i++) { // Boucle Y
            for(int j = -1 ; j <= 1 ; j++) { // Boucle X
                if((((posX + j) >= 0)) && ((posX + j) <= (sizeX - 1)) && (((posY + i) >= 0)) && ((posY + i) <= (sizeY - 1))) {
                    if((grid[posY + i][posX + j] == 1) && !(i == 0 && j == 0)) {
                        neighbors++;
                    }
                }
            }
        }
        
        return neighbors;
    }
    
    public int[][] getGrid() {
        return grid;
    }
    
    public int getSizeX() {
        return sizeX;
    }
    
    public int getSizeY() {
        return sizeY;
    }
    
    public boolean setCell(int x, int y, int value) {
        if((x >= 0) && (x <= (sizeX - 1)) && ((y >= 0)) && (y <= (sizeY - 1))) {
            grid[y][x] = value;
            return true;
        }
        else return false;
    }
    
    public int[][] copy2DArray(int[][] array) {
        int[][] ret = new int[array.length][];
        for(int i = 0; i < ret.length; i++) {
            ret[i] = new int[array[i].length];
            for(int j = 0; j < ret[i].length; j++) {
                        ret[i][j] = array[i][j];
            }
        }
        return ret;   
    }
    
    public void fill2DArray(int[][] array) {
        for(int i = 0; i < array.length; i++) {
            for(int j = 0; j < array[i].length; j++) {
                        array[i][j] = 0;
            }
        };   
    }
    
    public void tick() {
        int[][] tempGrid = this.copy2DArray(grid);
        
        for(int i = 0 ; i < sizeY ; i++) {
            for(int j = 0 ; j < sizeX ; j++) {
                if((this.getNeighbors(j,i) < 2) || (this.getNeighbors(j,i) > 3))
                    tempGrid[i][j] = 0;
                else if(this.getNeighbors(j, i) == 3)
                    tempGrid[i][j] = 1;
            }
        }
        grid = this.copy2DArray(tempGrid);
    }
}

tylrgsen

29 septembre 2011 à 22:19:10

Mouais... Je crois que je te prends 100-200 FPS sur 2200-2300, donc ça change pas grand chose, et encore, ça varie...
Et vu que tu n'as pas prévu d'extension(je parle de la grille de départ) et que j'ai la flemme, je vais pas essayer de monter les dimensions pour faire un benchmark xD .
Sinon, moi, j'attrape le tableau d'une image que je colle après en fonction de l'échelle de la fenêtre en fait.
Aussi, je n'ai pas créé de classe grille avec un tick, je fais tout dans ma classe screen.

Enfin, je n'utilise pas un tableau de tableaux d'entiers, je fais tout en un int[], avec x+y*width pour avoir la valeur d'un point.

Voilà mes codes, parce que ça pourrait toujours intéresser de voir à quel point on peut coder différemment. C'est par contre un peu crade au niveau de certains trucs, mais comme dit précédemment, c'était codé en 1h...

JVComponent.java

package com.hilaia.jeuvie;

import java.awt.Canvas;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.image.BufferStrategy;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferInt;
import java.util.Arrays;
import java.util.Random;

import javax.swing.JFrame;

public class JVComponent extends Canvas implements Runnable, MouseListener, KeyListener {
	public static int width = 80, height = 60, scale = 10;
	private Thread t;
	private boolean running;
	private Screen screen;
	private BufferedImage img;
	private BufferStrategy bs;
	public double minDeltaTime = 100000000; // 0.1 sec
	
	@Override
	public void run() {
		Random random = new Random();
		for(int i = 0; i < width* height; i++){
			screen.cells[i] = random.nextInt(2);
			System.out.println(screen.cells[i]);
		}
		createBufferStrategy(2);
		bs = getBufferStrategy();
		double lastTime = -minDeltaTime, now = 0;
		
		while(running){
			now = System.nanoTime();
			
			if(now - lastTime >= minDeltaTime){
				render();
				
				lastTime = now;
			}
		}
	}
	
	private void render() {
		screen.render();
		Graphics g = bs.getDrawGraphics();
		
		g.drawImage(img, 0, 0, width*scale, height*scale, null);
		
		bs.show();
	}

	public void start(){
		if(running)
			return;
		running = true;
		t = new Thread(this);
		t.start();
	}
	
	public void stop(){
		if(!running)
			return;
		running = false;
		try {
			t.join();
		} catch (InterruptedException e) { e.printStackTrace(); }
	}
	
	public JVComponent() {
		Dimension size = new Dimension(width*scale, height*scale);
		
		screen = new Screen(width, height);
		
		setSize(size);
		
		img = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
		screen.pixels = ((DataBufferInt)img.getRaster().getDataBuffer()).getData();
		
		addMouseListener(this);
		addKeyListener(this);
	}
	
	public static void main(String[] args){
		JVComponent m = new JVComponent();
		
		JFrame f = new JFrame("Jeu de la vie");
		f.setResizable(false);
		f.add(m);
		f.pack();
		f.setLocationRelativeTo(null);
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		m.start();
		
		f.setVisible(true);
	}

	@Override
	public void mousePressed(MouseEvent e) {
		if(e.getButton() == MouseEvent.BUTTON1)
			screen.cells[e.getX()/scale+e.getY()/scale*screen.width] = 1;
		else if (e.getButton() == MouseEvent.BUTTON2){
//			Ici, je permets de placer un canon si on décommente ceci, en appuyant sur le clic de la molette. Pour l'instant, c'est un un motif qui ne se stabilise qu'après + de 17 000 générations.
//			int model[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
//						   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
//						   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 
//						   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
//						   1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
//						   1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
//						   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
//						   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
//						   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 
//			};
			int model[] = {0, 0, 0, 0, 1, 0, 1, 0, 
						   1, 0, 1, 0, 0, 1, 0, 0, 
						   0, 1, 0, 0, 0, 1, 0, 0,
						   0, 1, 0, 0, 0, 0, 0, 1
			};
			int modelWidth = 8, modelHeight = model.length/modelWidth; //Régler la largeur à 36 pour le canon, si mes souvenirs sont bons.
			for(int j = 0; j < modelHeight; j++){
				for(int i = 0; i < modelWidth; i++){
					if((e.getX()/scale)+i >= 0 && (e.getX()/scale)+i < screen.width && (e.getY()/scale)+j >= 0 && (e.getY()/scale)+j < screen.height){
						screen.cells[(e.getX()/scale)+i+(e.getY()/scale+j)*screen.width] = model[i+j*modelWidth];

					}
				}
			}
		}
		else if (e.getButton() == MouseEvent.BUTTON3){
			for(int j = -1; j <= 1; j++){
				for(int i = -1; i <= 1; i++){
//					On vérifie que les cellules existent bien
					if((e.getX()/scale)+i >= 0 && (e.getX()/scale)+i < screen.width && (e.getY()/scale)+j >= 0 && (e.getY()/scale)+j < screen.height)
						screen.cells[(e.getX()/scale)+i+(e.getY()/scale+j)*screen.width] = 1;
				}
			}
		}
	}
	
	@Override
	public void mouseClicked(MouseEvent e) {
	}

	@Override
	public void mouseEntered(MouseEvent e) {
	}

	@Override
	public void mouseExited(MouseEvent e) {
	}


	@Override
	public void mouseReleased(MouseEvent e) {
	}

	@Override
	public void keyPressed(KeyEvent e) {
	}

	@Override
	public void keyReleased(KeyEvent e) {
		if(e.getKeyCode() == KeyEvent.VK_SPACE){
			Arrays.fill(screen.cells, 0);
		}
	}

	@Override
	public void keyTyped(KeyEvent e) {
	}
}

Screen.java

package com.hilaia.jeuvie;

import java.util.Arrays;

public class Screen extends Bitmap {
	public int[] cells;
	
	public Screen(int width, int height) {
		super(width, height, false);
		cells = new int[width*height];
	}

	public void render() {
		int[] ret = new int[width*height];
		for(int j = 0; j < height; j++){
			for(int i = 0; i < width; i++){
				int sum = sumNeightbours(i, j);
				if(sum == 2)
					ret[i+j*width] = cells[i+j*width];
				else if(sum == 3)
					ret[i+j*width] = 1;
				else if(sum < 2 || sum > 3)
					ret[i+j*width] = 0;
				pixels[i+j*width] = 0xff0000 * ret[i+j*width];
			}
		}
		cells = Arrays.copyOf(ret, width*height);
	}
	
	public int sumNeightbours(int x, int y){
		int ret = 0;
		for(int j = -1; j <= 1; j++){
			for(int i = -1; i <= 1; i++){
				if(x+i >= 0 && x+i < width && y+j >= 0 && y+j < height && i+j*3 != 0){
					ret += cells[x+i+(y+j)*width];
				}
			}
		}
		
		return ret;
	}
}

Bitmap.java(presque rien, juste une sup de Screen au cas où j'aurais voulu étendre le programme, avec des images pour les cellules, par exemple. Ca aurait permis de le faire en 5 minutes)

package com.hilaia.jeuvie;

public class Bitmap {
	public int pixels[];
	public int width, height;
	
	public Bitmap(int width, int height) {
		this(width, height, true);
	}
	
	public Bitmap(int width, int height, boolean init) {
		this.width = width;
		this.height = height;
		if(init) pixels = new int[width*height];
	}
}

JVApplet.java

package com.hilaia.jeuvie;

import java.applet.Applet;
import java.awt.BorderLayout;

public class JVApplet extends Applet {
	JVComponent m;
	
	public void init(){
		JVComponent.width = getWidth()/JVComponent.scale;
		JVComponent.height = getHeight()/JVComponent.scale;
		
		setLayout(new BorderLayout());
		
		m = new JVComponent();
		add(m);
	}
	
	public void start(){
		m.start();
	}
	
	public void stop(){
		m.stop();
	}
	
	public void destroy(){
	}
}

Je viens de remodifier un tout petit truc, mais ça devrait toujours fonctionner :-°

.

PS: Les noms des variables sont parfois... comiques aussi.

Ludavid21

29 septembre 2011 à 22:33:59

Oui alors je te comprends que tu veuilles pas essayer de modifier ma grille

Je viens de créer une classe EventHandler qui se chargera de recevoir les clicks de la souris et modifiera en fonction les cellules. Je pense que je vais aussi rajouter un raccourci clavier pour changer dynamiquement la taille des cellules ainsi que la taille de la grille, parce que là c'est chiant à faire

Ensuite j'ai un peu regardé ton code, je comprends pas trop certains bouts j'avoue, et d'autres me paraissent peu modulables comme la partie qui rempli la grille, elle dimensionne le tableau en fonction d'une forme déjà faite. Si on veut modifier la grille ça sera plus difficile. Chez moi j'ai fait en sorte que l'un s'adapte en fonction de l'autre. Par exemple je peux changer à tout moment la taille de ma grille et le rendre s'adaptera ensuite (reste plus qu'à changer la taille de la fenêtre). Après chacun fait comme il veut hein, je suis loin d'être un pro du java pour en juger sur la qualité d'un code^^

EDIT: Quant au tick() je me suis inspiré du code du créateur de minecraft, il utilise beaucoup cette structure de programme et je la trouve logique, donc je l'utilise