Discussion :

[perluce]

Bonjour,

j'ai un petit problème,

je veux tracer une droite parallèle, pour cela,je fais déplacer la souris sur une droite qui vérifie l'équation de la droite parallèle que je veux créer.J'utilise la classe java.awt.Robot et j'arrive bien à faire déplacer la souris. Mais après, je ne peux pas cliquer pour sélectionner les deux points de la droite.


Le code pour déplacer ma souris sur la droite

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 void mouseMoved(MouseEvent e) {
 
      if(etape==5){
 
      try{
         Robot r= new Robot();
         for (int i = 0; i < 300; i++)
           {
              for (int j = 0; j < 300; j++)
              {
                 if ((j - (a * i) - (c * 20)) < 0.5f && (j - (a * i) - (c * 20)) > -0.5f)
                   r.mouseMove((int)(i+this.getLocationOnScreen().getX()),(int)(j+this.getLocationOnScreen().getY()));
              }
           }
         // trouver comment faire pour cliquer sur le point voulu
          if(SwingUtilities.isRightMouseButton(e))
            {
                 r=null;
            }   
      }
       catch(Exception ex){
          System.out.println("Exception :"+ex.getMessage());
       }
 
      }
   }

Ce que j'aimerais faire dans mouseClicked

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 mouseClicked(MouseEvent e)
 
   {
   Graphics g = getGraphics();
if(etape==5){
         System.out.println("dans 6ème étape");
//        trouver comment faire pour cliquer sur le point voulu   
 if(SwingUtilities.isRightMouseButton(e))
            {
         p4 = new Point(e.getX(),e.getY());
         g.drawRect(p4.x,p4.y,1,1);
          }
          }
}

mais la souris se déplace juste sur la droite et je ne peux rien faire d'autre. Est ce que quelqu'un saurait comment je peux faire pour cliquer afin de créer mes points?

[Janitrix]

La classe Robot dispose d'une méthode mousePress :

mousePress(int buttons)
Presses one or more mouse buttons.

Tu passes en paramètre le bouton que tu veux cliquer (voir le lien pour plus d'info).

Je suis pas sur que c'est la meilleure méthode pour ce que tu veux faire, enfin bon...

Bon courage

[perluce]

merci pour l'ai janitrix mais ça ne me permet pas de faire ce que je veux. mousePress() va appuyer automatiquement un bouton alors que je veux que ce soit l'utilisateur qui puisse faire cela. En fait, ce qu'il faudrait c'est pouvoir faire interagir en même temps la souris normale et le robot. Mais je ne sais pas si cela est possible

[Yannick_from_31]

Bonjour,

A mon avis le soucis vient du fait que tu bouges la souris (par le Robot) dans un évènement (mouseMoved) géré par l'event dispatching thread (EDT)

Ainsi, l'EDT ne peut pas gérer d'autres évènement tant que tu ne sors pas de la fonction (mouseMoved) qui doit gérer cet évènement.

Donc, impossible de gérer les clics pendant que ton curseur bouge tout seul grâce au Robot.

Pour éviter ceci, tu dois lancer un Thread en parallèle qui fait le travail de ton robot pour libérer l'EDT et ainsi laisser l'EDT libre de capturer les clics en parallèle.

[perluce]

Dans le thread que je dois lancer en parallèle, je dois mettre dans la méthode run(), ce que doit faire mon robot? Puis le thread, je dois le lancer où? Dans ma méthode mouseClicked()? J'ai essayé de regarder vite fait comment faire des threads mais je n'ai pas réussi, j'ai sûrement dû me tromper quelque part.

[Yannick_from_31]

> Dans le thread que je dois lancer en parallèle, je dois mettre dans la
> méthode run(), ce que doit faire mon robot?

Oui c'est ça.

> Puis le thread, je dois le lancer où? Dans ma méthode mouseClicked()?

Non, dans mouseMoved puisque ton code du Robot est dans mouseMoved.
==> Dans mouseMoved : tu crée ton Thread et tu le lance (monThread.start()).

> J'ai essayé de regarder vite fait comment faire des threads mais je n'ai
> pas réussi, j'ai sûrement dû me tromper quelque part.

Tu crées une classe qui hérite de Thread ou tu redéfinis la méthode run() avec le traitement que fait le Robot.

[perluce]

c'est ce que je fais mais j'ai toujours le même problème.

Voilà le code de mon 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
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
 
import java.awt.Robot;
 
public class FirstThread extends Thread {
 
	PanelParallèle p;
 
    public FirstThread(PanelParallèle p) {
       this.p =p;
        this.start();
    }
 
    public void run() {
 
        	  try{
      			Robot r= new Robot();
      			System.out.println("début");
      			for (int i = 0; i < 300; i++)
      	        {
      	           for (int j = 0; j < 300; j++)
      	           {
      	        		System.out.println("milieu");
 
      	              if ((j - (p.a * i) - (p.b * 20)) < 0.5f && (j - (p.a * i) - (p.b * 20)) > -0.5f)
      	                r.mouseMove((int)(i+p.getLocationOnScreen().getX()),(int)(j+p.getLocationOnScreen().getY()));
      	        	System.out.println("fin");
      	           }
      	        }
      		}
      		 catch(Exception ex){
      			 System.out.println("Exception :"+ex.getMessage());
      		 }
 
            }
}

et le code dans mousemoved()

Code :

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

1
2
3
4
5
6
7
8
9
 
 
public void mouseMoved(MouseEvent e) {
		if((c==1) && (etape==5)){	
		System.out.println("début thread");
			  FirstThread thr1 = new FirstThread(this);
			  thr1.start();
		}
}

[Yannick_from_31]

Déjà au lieu de ça :

Code :

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

1
2
3
4
5
 
public FirstThread(PanelParallèle p) {
       this.p =p;
        this.start();
    }

il faut ça :

Code :

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

1
2
3
4
 
public FirstThread(PanelParallèle p) {
       this.p =p;
    }

Ensuite peut-être qu'il te faut exécuter le Thread par le biais de SwingUtilities.invokeLater pour ne pas gêner l'EDT.

Aussi, il te faut peut-être rajouter des Thread.yield() dans la fonction run().

[perluce]

j'ai encore quelques petits problèmes, notamment pour arrêter mon thread mais je vais chercher comment le faire. Merci Yannick_from_31 pour ton aide.

[perluce]

alors au début, j'ai réussi à tracer mon point mais le thread ne s'arrêtait pas directement après le clic. ensuite, j'ai modifié le code, et là, je ne peux plus dessiner mon point. Je ne sais plus trop quoi faire

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
 
import java.awt.Robot;
 
public class FirstThread extends Thread {
 
	PanelParallèle p;
	boolean actif;
 
    public FirstThread(PanelParallèle p) {
       this.p =p;
       this.actif=false; 
    }
 
    public void run() {
    	actif=true;
    	while(actif==true){
        	  try{
      			Robot r= new Robot();
      			for (int i = 0; i < 300; i++)
      	        {
      	           for (int j = 0; j < 300; j++)
      	           {
      	              if ((j - (p.coefDir2 * i) - (p.absOr2 * 20)) < 0.5f && (j - (p.coefDir2 * i) - (p.absOr2 * 20)) > -0.5f)
      	              r.mouseMove((int)(i+p.getLocationOnScreen().getX()),(int)(j+p.getLocationOnScreen().getY()));
      	           }
      	        }
      			Thread.yield();
      		}
      		 catch(Exception ex){
      			 System.out.println("Exception :"+ex.getMessage());
      		 }
            }
    }
 
    public void setActif(boolean a){
    	actif=a;
 
    }
}

Dans mon mouseMoved, j'ai:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
public void mouseMoved(MouseEvent e) {
 
		if((c==1) && (etape==5)){	
		  thr1 = new FirstThread(this);	
		  SwingUtilities.invokeLater(thr1);
			  //thr1.start();
		}
 
		if((c==1) && (etape==6)){	
			System.out.println("fin thread");
			thr1.setActif(false);
			  //thr1=null;
			}

[Yannick_from_31]

Oups ! Je crois t'avoir suggéré une connerie

J'ai pas du faire trop attention au code que tu donnais, pardon.

En fait, si ton Thread qui déplace le curseur tourne en boucle (tant que l'utilisateur ne clique pas) : tu devrais le lancer une seule et unique fois dès que tu en as besoin (au mouseClicked je pense ou au MouseMoved en vérifiant si pas déjà lancé).

En ensuite, stopper ton Thread avec ta méthode setActif(false) dès le nouveau clic de l'utilisateur.

Parce que sinon tu vas tout faire péter pour rien avec 15.000 Threads en parallèle lancés pour la même chose.

[perluce]

je l'ai déjà essayé et ça continue à tourner en boucle malgré les clics

[perluce]

Bonjour,

je reviens sur mon problème avec la classe java.awt.Robot. Etant donné que je n'ai eu aucune réponse, je met tout mon code en espérant que quelqu'un pourra trouver ce qui ne va pas parce que ça fait plus d'une semaine que je suis dessus et je n'y arrive pas.

Classe du 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
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
 
import java.awt.Robot;
 
/**
 * thread pour la construction d'une parallèle
 * @author au
 *
 */
 public class FirstThread extends Thread {
 
	PanelParallèle p;
	boolean actif;
 
 
	 public FirstThread(PanelParallèle p) {
       this.p =p;
       this.actif=false;
 
    }
 
	 public void run() {
    	actif=true;
 
    	while(actif==true){
    		try{
      			Robot r= new Robot();
      			for (int i = 0; i < 300; i++)
      	        {
      	           for (int j = 0; j < 300; j++)
      	           {
      	              if ((j - (p.coefDir2 * i) - (p.absOr2)) < 0.5f && (j - (p.coefDir2 * i) - (p.absOr2)) > -0.5f){
      	              r.mouseMove((int)(i+p.getLocationOnScreen().getX()),(int)(j+p.getLocationOnScreen().getY()));}
      	           }
      	        }
      		}
      		 catch(Exception ex){
      			 System.out.println("Exception :"+ex.getMessage());
      		 }
      		    }  	
    }
 
    public void setActif(boolean a){
    	actif=a; 	
    }
}

Classe qui définit un point

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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
 
 
import java.awt.*;
 
 
/**
 * Classe définissant un point et les opérations effectuées sur un point
 * 
 */
 
public class MonPoint extends Geometrie {
 
/**
 * 
*/
	private static final long serialVersionUID = 1L;
 
/**
 * <p>Abscisse du point</p>
 * 
 */
   public int x;
 
/**
 * <p>Ordonnée du point</p>
 * 
 */
    public int y;
 
    /**
     * Construit et initialise un point aux coordonnées a, o
     * @param a abscisse du point
     * @param o ordonnée du point
     */
    public MonPoint(int a, int o){
    	this.x=a;
    	this.y=o;
    }
 
/**
 * Définit l'abscisse d'un point
 * @param a abscisse du point
 */
    public void setX(int a) {        
       this.x=a;
    } 
 
/**
 * Définit l'ordonnée d'un point
 * @param o ordonnée du point
 */
    public void setY(int o) {        
       this.y=o;
    } 
 
/**
 * Retourne l'abscisse du point
 * @return abscisse du point
 */
    public int getX() {        
        // your code here
        return this.x;
    } 
 
/**
 *Retourne l'ordonnée du point
 * @return ordonnée du point
 */
    public int getY() {        
        // your code here
        return this.y;
    } 
 
/**
 * Calcule la distance entre le point et un autre point
 * 
 * @return distance entre les deux points
 */
    public int distance(MonPoint p) {
        int dx = p.x - x ;
        int dy = p.y - y ;
        int res= dx*dx + dy*dy;
        return res ;         
    } 
 
/**
 * effectue la rotation d'un point
 * @param a angle de rotation
 */
 
   public void rotation (double a)
   {             
   }
 
	public void affiche(Graphics g) {
		// TODO Auto-generated method stub
 
		Graphics2D g2 = (Graphics2D) g;
		 if (selected)
	         g2.setColor(Color.blue);
	      else
	         g2.setColor(Color.black);
 
        g2.drawRect(x,y,1,1);
 
 
	}
 
	public boolean contains(int x, int y) {
 
		return ((this.x==x) && (this.y==y));
 
	}
	public int nbPoints() {
		return 1;
	}
 
	@Override
	public String typeGeom() {
		return "point";
	}	
 }

Classe qui définit une ligne

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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
 
 
 
import java.awt.*;
 
 
/**
 * 
 * 
 */
public class Ligne extends Geometrie {
 
 
/**
         * 
         */
	private static final long serialVersionUID = 1L;
/**
 * <p>Tableau représentant tous les points de la ligne</p>
 * 
 */
   public MonPoint[] points;
   int size;
 
  /**
   * 
   *
   */ 
  public Ligne(){
	  this.points=null;
	  this.size=0;
  }
  /**
   * construit une ligne vide de taille s
   * @param s
   */
  public Ligne(int s){
	  this.points=null;
	  this.size=s;
  }
  /**
   * construit une ligne et l'initialise avec les points contenus dans p
   * @param p tableau contenant les points de la ligne
   */
  public Ligne(MonPoint p[]){
	  this.points=p;
	  this.size=p.length;
  }
 
/**
 * initialise les points de la ligne
 * 
 */
    public void setPoints(MonPoint p[]) { 
    	this.points=p;
          } 
 
/**
 * retourne les points de la ligne
 * 
 * @return points constituant la ligne
 */
    public MonPoint[] getPoints() {        
        // your code here
        return points;
    } 
 
/**
 * renvoie le nombre de points de la ligne
 * 
 * @return nombre de points de la ligne
 */
    public int nbPoints() {        
        // your code here
        return this.points.length;
    } 
 
/**
 * retourne le premier point de la ligne
 * 
 * @return premier point de la ligne
 */
    public MonPoint getPointDeb() {        
 
        return this.points[0];
    } 
 
/**
 * initilaise le point de début de la ligne à p
 * @param p point de début
 */
    public void setPointDeb(MonPoint p){
    	this.points[0]=p;
    }
 
 
/**
 * retourne le dernier point de la ligne
 * 
 * @return dernier point de la ligne
 */
    public MonPoint getPointFin() {        
 
        	return this.points[nbPoints()-1];
    } 
 
/**
 * initilaise le point de fin de la ligne à p
 * @param p point de fin 
 */
    public void setPointFin(MonPoint p){
    	this.points[nbPoints()-1]= p;
    }
 
 
 
 
  /**
   * donne l'image de la ligne par rapport au point o avec un angle a
   * @param o point de référence pour la rotation
   * @param a angle de rotation
   */
    public void rotation(double a) {        
        // your code here    
    }
 
 
public void affiche(Graphics g) {
	// TODO Auto-generated method stub
 
	Graphics2D g2 = (Graphics2D) g;
 
	 int[] abscisse = new int[this.points.length];
	    int[] ordonnee = new int[this.points.length];
	    // stock abscisses et ordonnées des sommets du polygone dans un tableau.
	    for (int i=0 ; i < this.points.length ; i++) {
	      abscisse[i] = this.points[i].getX();
	      ordonnee[i] = this.points[i].getY();
	    }
 
	    if (selected)
	         g2.setColor(Color.blue);
	      else
	         g2.setColor(Color.black);
 
	    for (int i=0; i<this.points.length-1; i++){
		 	this.points[i].affiche(g2);
	 }  
	  g2.drawPolyline(abscisse,ordonnee,abscisse.length);
 
}
 
 
public boolean contains(int x, int y) {
 
boolean verif = false;
 
	return verif;
}
 
public String typeGeom() {
	// TODO Auto-generated method stub
	return "ligne";
}
 
}

Classe geometrie

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
 
 
import java.awt.Graphics;
import java.io.Serializable;
 
public abstract class Geometrie implements Serializable{
 
  public boolean selected = false;
 
    public abstract void affiche(Graphics g) ;
 
    public abstract void rotation(double a);
 
    public abstract boolean contains (int x, int y);
 
      public abstract int nbPoints();
 
 	public abstract  String typeGeom();
}

Classe qui permet de dessiner

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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
 
import java.awt.*;
import java.awt.event.*;
import java.util.ArrayList;
import javax.swing.*;
 
 
public class Parallèle extends JFrame 
{
 
	private static final long serialVersionUID = 1L;
PanelParallèle panel = new PanelParallèle();
 
 
   public static void main (String[] args)
   {
	   Parallèle para = new Parallèle();
	   para.setVisible(true);
   }
 
   public Parallèle()
   {
      Dimension taille_ecran = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
      int hauteur_ecran = (int)taille_ecran.getHeight();
      int largeur_ecran = (int)taille_ecran.getWidth();
 
      setTitle("Parallèle");
      setLocation((largeur_ecran / 2) - (175), (hauteur_ecran / 2) - (200));
      setSize(350, 400);
 
      setLayout(null);
 
      panel.setBounds(20, 20, 300, 300);    
      add(panel);
      panel.setBackground(Color.white);
 
      this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
      this.setVisible(true);
 
   } 
}
 
class PanelParallèle extends JPanel implements MouseListener
{
	private static final long serialVersionUID = 1L;
   MonPoint p1, p2,p3,p4,p5;
   float coefDir1 = 0f;
   float absOr1 = 0f;
 
  public  float coefDir2 = 0f;
  public float absOr2 = 0f;
 
   String eqDroite1 = "";
   String eqDroite2 = "";
 
   int etape = 0;
   int x,y;
   String message = "";
   Parallèle par;
 
   ArrayList <Geometrie> forme = new ArrayList <Geometrie>();
   ArrayList <MonPoint> li2 = new ArrayList <MonPoint>();
   ArrayList <MonPoint> li = new ArrayList <MonPoint>();
 
   FirstThread  thr1;
 
   public PanelParallèle()
   {
	  setBackground(Color.white);
      addMouseListener(this);   
 
   }
 
   public void paintComponent(Graphics g)
		   {
		      super.paintComponent(g);
 
 
		      for (int i = 0; i < forme.size(); i++)
		      {
		         if (forme.get(i) instanceof Geometrie)
		         {
		        	 Geometrie geom= (Geometrie) forme.get(i);
		            geom.affiche(g);
		         }
		      }
		      g.setColor(new Color(0, 0, 0));
				}	
 
 
   public String CalculEqDroite1(MonPoint p, MonPoint pp)
   {
      System.out.println("1er point :" +p.x+ " "+p.y);
      System.out.println("2ème point :" +pp.x+ " "+pp.y);
 
      coefDir1 = (float) ((float) (pp.y - p.y)) / ((float) (pp.x - p.x));
      absOr1 =  (float) (p.y - (p.x * coefDir1)) ;
      return ("y = " + coefDir1 + "x + " + absOr1);
   }
 
   public String CalculEqDroite2()
   {
      coefDir2 = coefDir1;
      absOr2 =  (float) (p3.y - (p3.x * coefDir2));
      return ("y = " + coefDir2 + "x + " + absOr2);
   }
 
    public  void mouseClicked(MouseEvent e)
 
   {
	Graphics g = getGraphics();
 
 
		System.out.println("dans cas 1");   
      if (etape == 0)
      {
    	  System.out.println("dans 1ère étape");
         p1= new MonPoint(e.getX(),e.getY());
	p1.affiche(g);
	li2.add(p1);
	forme.add(p1);
 
      }
 
      if (etape == 1)
      {
    	System.out.println("dans 2ème étape");
        p2 = new MonPoint( e.getX(),e.getY());
        p2.affiche(g);
        li2.add(p2);
        forme.add(p2);
      }
 
      if (etape == 2)
      {
    	  System.out.println("dans 3ème étape");
    		Ligne l1 = new Ligne(li2.size());
			MonPoint[] tab = new MonPoint[li2.size()];
 
			for (int i=0; i<li2.size(); i++){
				tab[i]=li2.get(i);
				l1.points=tab;
			}
 
	l1.affiche(g);
	forme.add(l1);
         eqDroite1 = CalculEqDroite1(p1,p2);
         System.out.println(coefDir1);
      }
 
      if (etape == 3)
      {
    	  System.out.println("dans 4ème étape");
 
         p3 = new MonPoint( e.getX(),e.getY());
	 p3.affiche(g);
	 li.add(p3);
         forme.add(p3);
      }
 
      if (etape == 4)
      {
    	 System.out.println("dans 5ème étape");
         eqDroite2 = CalculEqDroite2();
         System.out.println(eqDroite2);
         System.out.println(coefDir2);
         System.out.println(absOr2);
      }
      if(etape==5){
    	  System.out.println("dans 6ème étape");
 
		  thr1 = new FirstThread(this);	
		  thr1.start(); 
 
		   thr1.setPriority(Thread.MIN_PRIORITY);
		 // System.out.println("fin thread");	   	
      }
 
     if(etape==6){
    	  System.out.println("dernière étape");
 
    	  thr1.setActif(false);
			System.out.println(thr1.actif);
			thr1=null;
			System.gc();
 
    			p4 = new MonPoint(e.getX(),e.getY());
 
    			System.out.println("p4 x" +p4.x);
    			System.out.println("p4 y" +p4.y);
    			p4.affiche(g);
    			li.add(p4);
    			forme.add(p4);
    			Ligne l2 = new Ligne(li.size());
    			MonPoint[] tab = new MonPoint[li.size()];
 
    			   	for (int k=0; k<li.size(); k++){
    			   		tab[k]=li.get(k);
    			   		l2.points=tab;
    			   		}
    			   	l2.affiche(g);
    			    forme.add(l2);	
 
     }
      etape++;
 
      this.repaint();
   }
 
   public void mousePressed(MouseEvent e)
   {
 
   }
 
   public void mouseReleased(MouseEvent e)
   {
 
   }
 
   public void mouseExited(MouseEvent e)
   {
 
   }
 
   public void mouseEntered(MouseEvent e)
   {
 
   }
}

Alors, les classes Ligne, MonPoint et Geometrie ne présentent aucun problème. Je oense que le problème doit se situer au niveau du code de mon thread ou dans la méthode mouseClicked() lorsque j'appelle le thread.

Le problème qui se pose est en fait qu'au clic après etape==5, je dois pouvoir créer mon point et arrêter le thread. Mais je n'y arrive pas, c'est après plusieurs tentatives de clics que j'arrive à créer le point et de ce fait, il n'est pas créé à l'endroit voulu parce que je ne sais pas exactement quand le clic est pris en compte.

J'explique vite fait, une fois qu'on exécute Parallèle, il suffit juste de cliquer à chaque fois sur le panel, et à chaque clic, on passe à l'étape suivante:
- au premier clic, on crée le premier point
- au deuxième clic, on crée le deuxième point
- au troisième clic, on crée la ligne
- au quatrième clic, on crée le point par lequel, la parallèle va passer
- au cinquième clic, on calcule l'équation de droite de la parallèle à créer
- au sixième clic, on lance le thread qui va se déplacer sur la droite qui vérifie l'équation de la parallèle
- au septième clic, l'utilisateur doit pouvoir créer le point de fin de la parallèle et le thread doit s'arrêter

Mais au septième clic,ça ne se passe pas comme je voudrais.

Si jamais quelqu'un arrive à voir à quoi est dû mon problème, ça m'aiderait beaucoup.

Merci d'avance pour l'aide.

perluce

[Yannick_from_31]

Je viens de tester.

Apparemment, c'est ton r.mouseMove qui gêne.
Mon idée : une solution de secours :
dessiner la droite et faire déplacer un curseur (une croix par exemple) sur ta droite et non la souris. Là ça marchera je pense.
AUtre chose : le curseur de la souris qui bouge tout seul : ça devient vite énervant (c'est généralement à éviter ou alors à limiter le plus possible).

[perluce]

merci pour ta réponse Yannick_from_31.
J'avais pensé à peu près à ta solution de secours mais sans penser à faire déplacer un curseur au lieu de la souris. Je vais essayer de chercher comment le faire, en espérant que cela résoudra mon problème.