Discussion :

[javator]

Bonjour, je fais un programme graphique dans lequel mon KeyListener modifie les variables d'un tableau.Cependant, mon Listener traite plus rapidement cette saisie que le rafraichissement de mon canvas.

Je peus donc créer un Thread qui va copier sur un nouveau tableau les variables du précédent tableau: mais si je dépasse la pulsation du Thread, je doit réinitialiser le premier tableau pour avoir la fluidité!

Sinon je peus mettre une condition sur l'écriture du tableau en milisecond pour ajuster le changement des variables à mon canvas(j'ai pas trop envis)!


Et en dernier, ce que je me demande; est ce qu'il y a une commande pour ralentir mon Thread KeyListener ou est ce qu'il y a une façon d'implementer mon KeyListener dans un deuxième Thread.

public class OutputListener implements KeyListener{

DrawScreen draw;
Camera camera;

public OutputListener(DrawScreen draw){
this.draw=drawGL;
camera=new Camera();
}


public void keyPressed(KeyEvent keyevent){

if (keyevent.getKeyCode()==KeyEvent.VK_ESCAPE){
System.exit(0);
}

if (keyevent.getKeyCode()==KeyEvent.VK_UP){
camera.addtoCameraPosition(1,0,0);
}

if (keyevent.getKeyCode()==KeyEvent.VK_DOWN) {
camera.addtoCameraPosition(-1,0,0);
}

if (keyevent.getKeyCode()==KeyEvent.VK_LEFT) {
camera.addtoCameraPosition(0,-1,0);
}

if (keyevent.getKeyCode()==KeyEvent.VK_RIGHT) {
camera.addtoCameraPosition(0,1,0);

}


draw.genCameraPosition(camera.cameraPosition);

}

public void keyReleased(KeyEvent keyevent){}

public void keyTyped(KeyEvent keyEvent){}


}

[gifffftane]

J'ai quelque mal à comprendre, toujours est-il qu'à mon avis c'est toujours tangent de traiter les problèmes de thread avec des tempos ; des fois cela sort de situations difficiles, mais c'est plus de la chance qu'autre chose.

Il me semble qu'il vaut mieux se caler sur le bon événement - le créer si nécessaire. J'ai l'impression que le bon événement serait la fin de l'action de raffraichissement de ton canvas, à partir duquel il serait d'actualité de répondre à l'événement keyListener ; mais c'est ce que j'ai du mal à comprendre à la lecture de ta question : je ne vois vraiment pas pour quelle raison il faudrait attendre un rafraichissement de canvas pour répondre à un keyListener.

Enfin... toi, tu sais, et le principe que je te propose reste le même.

[javator]

Le probleme, c'est que si je reste appuyé sur la touche "f", le KeyListener va créer plus de "f", donc d'appel à la fonction KeyType() que je n'ai de temps pour traiter les informations et les afficher à l'écran.

[broumbroum]

faut plutot utiliser KewReleased dans ce cas la touche est enregistree lorsque tu relaches...

[javator]

je suis d'accord, mais l'utilisation du Thread KeyListener n'est pas optimisé pour mon programme: car j'ai besoin d'un Thred plus lent; même si j'execute mon programme de maniere à suivre le rafraichissement du canvas.

Le thread utilise du temps e calcul

[gifffftane]

Là je tenterais une solution bourrin : je présume que tu lances un thread pour faire ton calcul, alors, à reception d'un keyTyped, je vérifierais si le thread est en cours avant d'en lancer un autre. S'il est en cours, alors je ne fais rien. Et s'il n'est pas en cours, alors j'en lance un autre.

[broumbroum]

je suis d'accord, mais l'utilisation du Thread KeyListener n'est pas optimisé pour mon programme: car j'ai besoin d'un Thred plus lent; (...)

Le thread utilise du temps e calcul

Pour cela il y a les priorités de processus. de MIN_PRIORITY a MAX_PRIORITY en passant par la priorité normale: NORMAL_priority definie a 6 sur 10.

Code :

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

((Thread)t).setPriority(int level);

tu mettrais MIN_PRIORITY ainsi les Threads JVM de fond passe en NORMAL avant le tien.

[javator]

Merci pour les reponses, mais pour le setpriority(), j'ai pas tout à fait compris: j'ai fais un essai; et voici le code.
J'incrémente c1 et c2; le nombre de boucle du thread , et la boucle du KeyListener quand je reste appuyé.

Suivant le Thread.sleep que je rentre, la difference entre c1 et c2 passe de + à -.


Cependant, j'ai placé un setpriority() mais je ne vois pas quel effet il a?

public class Listener{
static Thread refreshThread;;
int c1=0,c2=0;
boolean first=true;


public Listener(){
render();
}




public void render(){
refreshThread=new Thread(){

public void run(){
((Thread)refreshThread).setPriority(1);
int r=0;
while(r!=1){

c1++;
if(!first)System.out.println((c1-c2));


try {
refreshThread.sleep(300);
} catch (InterruptedException e) {e.printStackTrace();}

}
}
};
refreshThread.start();

}



}

______________________________________________________

public class OutputListener extends Listener implements KeyListener{



int t=0;

public OutputListener(){
initListener();
}





public void keyPressed(KeyEvent keyevent){

if(first){c1=0;c2=0;first=false;System.out.println("keyPressed.........................");}

c2++;
//.........
}
public void keyReleased(KeyEvent keyevent){
System.out.println("keyReleased...........................");
first=true;
}


public void keyTyped(KeyEvent keyEvent){
}



}

[broumbroum]

setPRiority definit la priorite d'execution du Thread. par ex. si la JVM sature elle executera les Thread de plus haute priorite en premier. Ainsi un Thread de rendu graphique pourrait s'executer plus rapidement qu'un Thread de chargement d'objets, etc.