Problème de border ( drawRect dans une Jframe)

**Askiarsh** · 13/05/2017, 11h39

Bonjour,
J'ai un programme tout bête qui m'affiche une image en fond d'un Jframe, et un rectangle qui sert de curseur. J'arrive à le déplacer par clavier... cependant....
quelle que soit les dimensions de mon Jframe, le rectangle devient "invisible" au delà d'une certaine distance du point 0;0... (Je dirais à la moitié de l'axe des x et aux 2/3 de l'axe des y).
Pour être plus précis, j'ai println() les coordonés du rectangle et il continue en fait sa course même si je ne le vois plus.
Voici le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package jeux2;
import javax.swing.JFrame;
import java.awt.Dimension;
 
public class Main {
 
	public static Fond fond = new Fond();
 
	public static void main(String[] args){
		JFrame fenetre = new JFrame("Test");
		fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		fenetre.setSize(new Dimension(1920, 1200));
		fenetre.setLocationRelativeTo(null);
		fenetre.setResizable(false);
		fenetre.setAlwaysOnTop(false);
		fenetre.setUndecorated(true);
		fenetre.setContentPane(fond);
		fenetre.setVisible(true);    
	}
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package jeux2;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
 
public class clavier implements KeyListener{
 
	//@Override
	public void keyPressed(KeyEvent e) {
		if(e.getKeyCode() == KeyEvent.VK_Z){
			Main.fond.setDy(-5);
		}
		if(e.getKeyCode() == KeyEvent.VK_S){
			Main.fond.setDy(5);
		}
		if(e.getKeyCode() == KeyEvent.VK_Q){
			Main.fond.setDx(-5);
		}
		if(e.getKeyCode() == KeyEvent.VK_D){
			Main.fond.setDx(5);
		}
	}
 
	@Override
	public void keyReleased(KeyEvent arg0) {
		Main.fond.setDx(0);
		Main.fond.setDy(0);
	}
 
	@Override
	public void keyTyped(KeyEvent arg0) {
		// TODO Auto-generated method stub
 
	}
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
package jeux2;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import javax.swing.ImageIcon;
import javax.swing.JPanel;
 
public class Fond extends JPanel { 
 
	private static final long serialVersionUID = 2290215993065771323L;
 
	public int x ;
	public int y ;
	public int dx ;
	public int dy ;
 
	public ImageIcon icoFond;	
	public Image fond;
 
	public Fond(){
		super();
		icoFond = new ImageIcon(getClass().getResource("img/earth_map_ocean_continents_1920x1200.jpg"));
		this.fond = this.icoFond.getImage();	
 
		this.setFocusable(true);
		this.addKeyListener(new clavier());
 
		Thread chrono = new Thread(new Chrono());
		chrono.start();
	}
 
	public void paintComponent(Graphics g){
		super.paintComponent(g);
		Graphics g2 = (Graphics2D)g;
		g2.drawImage(this.fond,0,0,null);
		g2.setColor(Color.RED);
		g2.drawRect(this.getX(),this.getY(),32,32);
		System.out.println(this.getX());
		this.deplacement();
	}
 
	public void deplacement(){
		this.x = this.x + this.dx ;
		this.y = this.y + this.dy;
	}
 
	// Getters et Setters
	public int getX() {
		return x;
	}
 
	public void setX(int x) {
		this.x = x;
	}
 
	public int getY() {
		return y;
	}
 
	public void setY(int y) {
		this.y = y;
	}
 
	public int getDx() {
		return dx;
	}
 
	public void setDx(int dx) {
		this.dx = dx;
	}
 
	public int getDy() {
		return dy;
	}
 
	public void setDy(int dy) {
		this.dy = dy;
	}
 
	public Image getFond() {
		return fond;
	}
 
	public void setFond(Image fond) {
		this.fond = fond;
	}
 
	public static long getSerialversionuid() {
		return serialVersionUID;
	}
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package jeux2;
 
public class Chrono implements Runnable{
	private int PAUSE = 3;
	@Override
	public void run() {
			while(true){
				Main.fond.repaint();
				try {
					Thread.sleep(PAUSE);
				} catch (InterruptedException e) {}
				}
			}
	}

**joel.drigo** · 13/05/2017, 12h30

Salut,

Les méthodes getX(), setX(), getY() et setY() sont des méthodes de JPanel que Swing utilise pour positionner le JPanel dans son conteneur parent (pour savoir où le dessiner). Toi tu les redéfinies pour gérer ton truc à toi, ce qui fait donc foirer Swing.

Par ailleurs, ton système de déplacement n'est pas logique : faire un repaint à interval régulier et faire que le paint déplace l'objet. La logique c'est faire un déplacement à intervalle régulier, qui fait un repaint pour rafraichir. Le redessin tu ne le contrôle pas : il va se faire quand tu le demandes avec repaint() mais peut se faire dans d'autres conditions, et donc ton rectangle va se déplacé possiblement quand il ne faut pas.

**Askiarsh** · 14/05/2017, 17h16

Bonjour,
Je vois l'idée pour les set / get mais pourtant je ne les ai pas modifié ... :s par exemple quand je demande une auto génération des get/set (en clic droit -->source --> setters and getters) j'obtiens :
public int getX() {
return x;
}
ce qui est la définition que je donne dans mon code précédent ... Du coup je ne comprends pas en quoi le fait d'utiliser ces méthodes pose problème.
Du coup entre temps ce que j'ai fait c'est que j'ai généré une fenetre bien plus grande que mon fond, du coup pas de soucis pour que le curseur aille ou je veux.
Sinon je vais voir ce que je peux faire pour le repaint().
Merci de ton aide

**joel.drigo** · 14/05/2017, 19h40

Oui m'enfin l'autogénération se base sur le nom des attributs que TU as créés. Comme ils s'appelent x et y, et bien, tu as obtenu getX(), setX(), setY() et getY(). On peut certe déplorer que l'IDE ne previenne pas qu'on cache des méthodes existantes (en revanche, après création on le voit très clairement).

La méthode getX() est utilisé par Swing. Elle a un sens particulier pour Swing. Il en fait quelque chose qui dépend de son sens. Si tu redéfinis cette méthode et que tu en change le sens par des valeurs retournées qui ne correspondent pas à ce qu'elles devraient être, alors Swing ne fait plus ce qu'il est censé faire, et donc le résulat n'est pas le résultat normal.

C'est comme si tu as une classe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
public class Produit {
  private double prix;
  private double tva;
  public double getPrixDeVente() {
         return prix+prix*tva;
  }
}

et que tu définis une classe comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
public class MonProduit extends Produit {
  public double getPrixDeVente() {
         return 42;
  }
}

Et bien, tous les MonProduit vaudront 42 euros, et se foutront de leur prix hors taxe et du taux de tva.
Si tu as une méthode qui fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
public static double getPrixTotal(List<Produit> produits) {
     double prix=0;
     for(Produit produit : produits) {
              prix+=produit.getPrixDeVente();
     }
     return prix;
}

si tu lui passes une liste qui ne contient que des MonProduit, tu obtiendras 42*le nombre de produits en résultat.

**Askiarsh** · 14/05/2017, 22h08

Haaaa... ok tout s'explique . Sympa ce genre de petite surprise ^^.
Du coup merci de l'explication. Néanmoins je me suis débrouillé en "bidouillant" avec ces méthodes. Rien de très pro mais ça le fait.
Avant de clore le sujet, vu que je "tiens" quelqu'un qui m'explique les choses, j'aurais besoin d'un peu d'aide sur un petit truc.
J'ai une classe chrono comme tu as vu, et j'essaye de permettre au joueur de mettre le jeux en "pause". Pour cela j'affecte une touche dans ma classe clavier :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
//pause
		if(e.getKeyCode() == KeyEvent.VK_P){
			System.out.println("pause");
			Main.chrono.setA(false);
			System.out.println(Main.chrono.getA());
	}

Et ensuite je modifie ma classe chrono :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
package jeux2;
 
public class Chrono implements Runnable{
	private int PAUSE = 3;
	public boolean a = true ;
	@Override
	public void run() {
			while(a == true){
				Main.fond.repaint();
				System.out.println("en cours");
				try {
					Thread.sleep(PAUSE);
				} catch (InterruptedException e) {}
				}
			}
	public void setA(boolean e){
		this.a = e;
	}
	public boolean getA(){
		return this.a;
	}
	}

Du coup j'ai bien le message "pause" et syso(a) me donne bien "false" lorsque que j'appuie sur "P" ... mais le jeux continue de tourner ...Pourtant j'ai bien ma boucle while(a) et donc en l'occurrence while(false) ... bref c'est à n'y rien comprendre ^^

**joel.drigo** · 15/05/2017, 07h23

Envoyé par Askiarsh

Haaaa... ok tout s'explique . Sympa ce genre de petite surprise ^^.
Du coup merci de l'explication. Néanmoins je me suis débrouillé en "bidouillant" avec ces méthodes. Rien de très pro mais ça le fait.

Il n'y a rien à bidouiller. Il suffit de changer le nom de tes méthodes (genre setRectangleX() et getRectangleX()).

Envoyé par Askiarsh

Avant de clore le sujet, vu que je "tiens" quelqu'un qui m'explique les choses, j'aurais besoin d'un peu d'aide sur un petit truc.
J'ai une classe chrono comme tu as vu, et j'essaye de permettre au joueur de mettre le jeux en "pause". Pour cela j'affecte une touche dans ma classe

Chaque thread conserve une copie des valeurs. Lorsque tu modifies une variable dans un thread, sa valeur n'est pas changée dans l'autre. Tu changes la valeur de a dans l'Event Dispatch Thread, donc ton thread qui boucle n'est pas affecté. Pour gérer ce genre de cas, il te suffit de déclarer a volatile.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public volatile boolean a = true ;

(Enfin, moi, je mettrais cette variable privée)
En revanche, ton code ne réalise pas une pause du thread, mais un arrêt définitf du rafraichissement.
Pour faire une pause du rafraichissement, ce serait plutôt :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class Chrono implements Runnable{
	private static final int PAUSE = 3;
	private volatile boolean run = true ;
	private volatile boolean pause = false ;
	@Override
	public void run() {
			while(run){
                                if ( !pause ) {
				   Main.fond.repaint();
				   System.out.println("en cours");
                                }
				try {
					Thread.sleep(PAUSE);
				} catch (InterruptedException e) {
				}
			}
        }
	public void setPause(boolean pause){
		this.pause = pause;
	}
	public void stop(){
		this.run = false;
	}
	public boolean isPasue(){
		return this.pause;
	}
	}

Mais dans le cas de la pause, on bouclerait à vide, ce qui fait une consommation de cpu inutile. On peut faire mieux :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public class Chrono implements Runnable {
	private static final int PAUSE = 3;
	private volatile boolean run = true;
	private volatile boolean pause = false;
	private final Object semaphore = new Object();
 
	@Override
	public void run() {
		while (run) {
			while (!pause) {
				synchronized (semaphore) {
					try {
						semaphore.wait();
					} catch (InterruptedException e) {
					} // met le thread en attente par la variable semaphore
				}
			}
			//Main.fond.repaint();
			System.out.println("en cours");
			try {
				Thread.sleep(PAUSE);
			} catch (InterruptedException e) {
			}
		}
	}
 
	// met le repaint en pause
	public void setPause(boolean pause) {
		this.pause = pause;
		if ( !pause ) {
			synchronized (semaphore) {
				semaphore.notify(); // envoie un signal sur la variable semaphore qui va débloque le wait
			}
		}
	}
 
	// arrête le thread
	public void stop() {
		this.pause = false; 
		this.run = false;
	}
 
	public boolean isPasue() {
		return this.pause;
	}
}

**Askiarsh** · 15/05/2017, 12h33

ça me parraissait clair ... jusqu'à ce que je modifie mon code et que ça ne fonctionne pas ^^.
Test avec le code suivant :
Chrono :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
public class Chrono implements Runnable{
	private static final int PAUSE = 3;
	private volatile boolean run = true ;
	private volatile boolean pause = false ;
	@Override
	public void run() {
			while(run){
                                if ( !pause ) {
				   Main.fond.repaint();
				   System.out.println("en cours");
                                }
				try {
					Thread.sleep(PAUSE);
				} catch (InterruptedException e) {
				}
			}
        }
	public void setPause(boolean pause){
		this.pause = pause;
	}
	public void stop(){
		this.run = false;
	}
	public boolean isPasue(){
		return this.pause;
	}
	}

Clavier :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
if(e.getKeyCode() == KeyEvent.VK_P){
			System.out.println("pause");
			Main.chrono.setPause(true);
			System.out.println(Main.chrono.isPasue());
	}

La touche P semble bien déclencher le setPause(true) puisque la console me donne :
...
en cours
en cours
en cours
en cours
pause
true
en cours
en cours
en cours
...
Sauf que comme tu vois la boucle while ne s'arrête pas pour autant et le rafraichissement continu ... pourtant cette fois la variable pause est bien volatile ... :s
Après je me demande un truc, est ce que dans la mesure où pour le moment la seul chose que fais mon programme c'est déplacer un curseur de région en région , est ce que je n'aurais pas mieux fait de mettre un while(pause) directement dans la classe clavier. Un truc du style

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
private boolean pause = false;
while(!pause){
// là je rentre tout mon code avec toutes les actions de type  if(e.getKeyCode() == KeyEvent.VK_Z){ ...
//et je rajoute 
if(e.getKeyCode() == KeyEvent.VK_P){
this.pause = true ;
}

Et puis si j'ai d'autres objets plus tard qui sont gérés par le programme je met à chaque fois la même boucle et un lien vers le keylistener... non ?

P.S : quand je disais que je bidouillais c'est qu'en fait j'ai gardé les méthodes setX et setY telles qu'elles... et comme le soucis c'était que seul une proportion de la Jframe était accessible ... et bin j'ai ouvert une fenetre 4* trop grande pour mon écran et j'ai accès à toute la place qu'il me faut ^^.

**joel.drigo** · 15/05/2017, 14h11

Envoyé par Askiarsh

...
Sauf que comme tu vois la boucle while ne s'arrête pas pour autant et le rafraichissement continu ... pourtant cette fois la variable pause est bien volatile ... :s

Si le rafraichissement continu, c'est que tu as des repaint() ailleurs, ou d'autres types de méthodes qui font du rafraichissement. Ou alors que tu fais un Main.chrono.setPause(false). Tu le fais où (et quand donc) ce setPause(false) ? Normalement, on devrait avoir :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public class clavier implements KeyListener{
 
	//@Override
	public void keyPressed(KeyEvent e) {
                if (e.getKeyCode() == KeyEvent.VK_P){
			System.out.println("pause");
                        if ( Main.chrono.isPause() ) { // si chrono est en pause on le redémarre
			        Main.chrono.setPause(false);
                        }
                        else {
			        Main.chrono.setPause(true); // sinon on le met en pause
                        }
			System.out.println("En pause: " + Main.chrono.isPause());
	       }
                if ( !Main.chrono.isPause()  ) { // on ne prend en charge les autres touches que si on n'est pas pause
		if(e.getKeyCode() == KeyEvent.VK_Z){
			Main.fond.setDy(-5);
		}
		if(e.getKeyCode() == KeyEvent.VK_S){
			Main.fond.setDy(5);
		}
		if(e.getKeyCode() == KeyEvent.VK_Q){
			Main.fond.setDx(-5);
		}
		if(e.getKeyCode() == KeyEvent.VK_D){
			Main.fond.setDx(5);
		}
                }
	}
 
	@Override
	public void keyReleased(KeyEvent arg0) {
		Main.fond.setDx(0);
		Main.fond.setDy(0);
	}
 
	@Override
	public void keyTyped(KeyEvent arg0) {
		// TODO Auto-generated method stub
 
	}
 
}

De toute manière, si le rafraichissement devrait intérrompue lorsque que le jeu est en pause, c'est surtout le reste qui doit l'être (le déplacement du rectangle entre autres).

Envoyé par Askiarsh

Après je me demande un truc, est ce que dans la mesure où pour le moment la seul chose que fais mon programme c'est déplacer un curseur de région en région , est ce que je n'aurais pas mieux fait de mettre un while(pause) directement dans la classe clavier. Un truc du style

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
private boolean pause = false;
while(!pause){
// là je rentre tout mon code avec toutes les actions de type  if(e.getKeyCode() == KeyEvent.VK_Z){ ...
//et je rajoute 
if(e.getKeyCode() == KeyEvent.VK_P){
this.pause = true ;
}

Non, ça c'est absurde : tout ce que tu vas avoir c'est que quand tu vas appuyer sur la touche, ton application va se figer (puisque le code de traitement est une boucle), et tu ne pourras plus la défiger. Parce que ça s'exécute dans l'Event Dispatch Thread et boucle dans l'EDT signifie plus d'interraction et plus de rafraichissement.
Le plus simple serait de tester la pause dans le keylistener (comme dans mon exemple ci-dessus). Sinon désenregistrer le keylistener, et d'enregistrer un keylistener qui ne sert qu'à faire le setPause(false), et de faire l'inverse.

Envoyé par Askiarsh

Et puis si j'ai d'autres objets plus tard qui sont gérés par le programme je met à chaque fois la même boucle et un lien vers le keylistener... non ?

Je ne comprends pas trop de quoi tu parles par "lien vers le keylistener".

Envoyé par Askiarsh

P.S : quand je disais que je bidouillais c'est qu'en fait j'ai gardé les méthodes setX et setY telles qu'elles... et comme le soucis c'était que seul une proportion de la Jframe était accessible ... et bin j'ai ouvert une fenetre 4* trop grande pour mon écran et j'ai accès à toute la place qu'il me faut ^^.

[/QUOTE]
Pourquoi ne pas changer simplement le nom des méthodes ? Tant que tu laisses tes méthodes getX() et getY() tu empêches Swing de fonctionner correctement.

**Askiarsh** · 15/05/2017, 15h33

En effet j'avais oublié cette ligne
if ( !Main.chrono.isPause() ) {
devant les commandes de déplacement ... du coup ça risquait pas de bloquer les commandes.
Par contre la boucle while semble toujours fonctionner ... même quand pause = true. La console me donne toujours
...
en cours
en cours
pause
En pause : true //+ commandes bloquées
en cours
en cours
...

Du coup si j'ai bien compris ça bloque les commandes mais pas le repaint() ... et pourtant j'ai vérifié j'ai aucun repaint() ailleurs ...
Du coup si ça peux aider je met mes classes en PJ
Chrono.java
clavier.java
Fond.java
Main.java

Pour ce qui est du setX disons que ça fonctionne et que j'ai la flemme de tout réecrire ... au risque devoir le faire quand même plus tard ^^''

**joel.drigo** · 15/05/2017, 15h57

Forcément, ta variable Main.chrono ne référence pas la même instance que celle utilisée par le thread.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Main {
 
	public static Fond fond = new Fond();
	public static Chrono chrono = new Chrono();
 
	public static void main(String[] args){
		JFrame fenetre = new JFrame("Test");
		fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		fenetre.setSize(new Dimension(4000, 2500));
		fenetre.setLocationRelativeTo(null);
		fenetre.setResizable(false);
		fenetre.setAlwaysOnTop(false);
		fenetre.setUndecorated(true);
		fenetre.setContentPane(fond);
		fenetre.setVisible(true);   
		new Thread(chrono).start();
 
	}
}

Et là si tu fais ça dans la méthode run de la classe Chrono :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public void run() {
			while(run){
                if ( !pause ) {
				   Main.fond.repaint();
				   System.out.println("en cours");
                }
                else {
                	System.out.println("en pause");
                }
				try {
					Thread.sleep(PAUSE);
				} catch (InterruptedException e) {
				}
			}
        }

Tu verras "en cours" s'afficher continuellement tant que ça tourne, et "en pause" tant que c'est en pause.

**Askiarsh** · 15/05/2017, 16h48

Niquel ! un grand merci !

Problème de border ( drawRect dans une Jframe)

Agents de placement/Fenêtres Java

Discussions similaires

Partager

Partager