boucle valable en console mais pas pour le GUI !

Version imprimable

bonjour, je suis entrain d'apprendre les boucles avec swing et pour générer et afficher à l'infini un nombre aléatoire en console ça fonctionne mais pas sur le panel hélas... il faut 2 thread? je vois pas, en tout cas avec le do { et while(true) de la méthode dp3m : le panel ne s'affiche plus.. merci d'avance si vous savez comment arranger ça pour que les 2 s'affichent et défilent en même temps :-)

Code:

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
 
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.io.IOException;
import java.util.Random;
 
import javax.swing.JFrame;
import javax.swing.JPanel;
 
	public class Testframe3 extends JFrame implements Runnable  {
 
	int drawingTiles = 0;
 
	int tiles[][] = new int[8][8];
    int i,j;  
    int a, b;
 
 
 
    public static void main(String args[] ) throws IOException {
 
    Runnable r0 = new Testframe3();	
    for (int t=0; t<10;  t++ )   {
    Thread t0 = new Thread(r0);	
    t0.start();
 
 
    }
 
    }
    private void init() {
        DrawPanel3 p = new DrawPanel3();
        p.setBackground(Color.black);p.setForeground(Color.red);
        add(p);
    }
 
 
    public Testframe3() {
    	  init();  
    	  setDefaultCloseOperation(3);
          pack();
          setLocationRelativeTo(null);
          setVisible(true);
 
    }
	@Override
	public void run() {
 
	}           
 
}

Code:

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
class DrawPanel3 extends JPanel implements Runnable{   // ajouté
  //  		int tiles[][] = new int[8][8];
    	    int i,j;  
    	    int a, b;
        protected int drawingTiles = 0;
 
        private int tiles[][] = new int[8][8];
 
		public int[][] getTiles() {
			return tiles;
		}
 
		public void setTiles(int[][] tiles) {
			this.tiles = tiles;
		}
		public DrawPanel3() {
     //       Runnable r1 = new DrawPanel3();	
        	dp3m();
        }
        public void dp3m() {
            	this.setBackground(Color.black);this.setForeground(Color.red);	
           	  do {
                      JPanel p1 =new JPanel();
                      for (a=0;a<tiles.length;a++  ) {
                      	for (b=0;b<tiles.length;b++  ) {
                      		tiles[ a ][ b ] = 0;  
 
                      Random r = new Random();
                      for( i=0; i<tiles.length; i++){
                          for( j=0; j<tiles.length; j++){
//                            	if (j>=5 && i>=5) {
//                          		i=0;j=0;
                         	 tiles[i][j]=0;                	
                         	tiles[ i ]  [ j ] = r.nextInt(150);
 
                      System.out.printf("%s\n" , tiles [i][j]  ) ;
                         }   } 	}  	}  }    
              	while ( true);    	}	
 
 
        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
//            while(getTiles() != null  ) {
            int curTiles = 0;
            int a,b;
 
   //              do {
 
//            	for (a=0;a<tiles.length;a++  ) {
//                	for (b=0;b<tiles.length;b++  ) {
//                		tiles[ a ][ b ] = 0;  
            	for(int i=0;i<tiles.length;i++){
                for(int j=0;j<tiles.length;j++){
 
                        g.drawString(getTiles()[i][j]+"", (j+1)*40, (i+1)*40);
 
 
//                    }
//                }
            }
        } }
//        while(true); }
            @Override
        public Dimension getPreferredSize() {
            return new Dimension(512,512);
        }
			@Override
			public void run() {
 
			}
    }

30/10/2021, 03h20
anadoncamille

Me fiant à mes anciens souvenirs de swing, il me semble que tu n'as pas besoin de créer de tâches supplémentaires. Tes composants n'ont pas à implémenter Runnable, d'autant que tes méthodes run sont vides. Ce que je te conseille, c'est d'apprivoiser le fonctionnement d'une JFrame avec un simple hello world, puis faire la même chose avec un JPanel. Entraine-toi à les initialiser, à changer leur apparence puis à surcharger la méthode paintComponent, etc... Lis bien la documentation.

Un truc que je ne comprends pas dans ton code : pourquoi tu lances 10 instances de ta fenêtre ?
31/10/2021, 02h58
suzut

voila

merci; j'avais pas completé le run; j'ai corrigé et sans implémenter runnable j'ai pu refaire ça correctement en testant par lambda
Runnable r0 = () -> { init4(); pack();}; la bouche posait un problème également... et testé aussi sans créer de thread: c'était 1 petit souci au niveau de la boucle dans la méthode dp3m j'avais oublié de fermer les 2 "for" avec }} ... désolé j'ai vraiment été naz et la prochaine fois j'aurais de meilleurs questions lol merci encore
31/10/2021, 12h46
anadoncamille

Ton problème est-il résolu, du coup ?
31/10/2021, 20h43
suzut

*

oui merci d'avoir répondu; je vais passer beaucoup plus de temps sur tout ça maintenant...

JPanel qui ne repaint pas

hello
j'ai fais une class pour tenter d'afficher des images à partir de fichiers sur un panel mais le paintcomponent ne reçoit rien, voici le class:

Code:

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
package slider;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
 
import javax.imageio.ImageIO;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.filechooser.FileNameExtensionFilter;
 
 
public class ScrollBackx {
 
    public static void main(String args[] ) {
 
    	JFrame j0 = new JFrame(); j0.setDefaultCloseOperation(3);
 
 
    	JButton jb0 = new JButton();
    	Liste lst = new Liste();
 
    	j0.setBackground(Color.gray);
 
    	j0.setSize(lst.img.getWidth(), lst.img.getHeight());
    	lst.setVisible(true);
    	lst.initcmp(lst.img,jb0,null);
    	j0.setContentPane(lst);		
    	j0.setVisible(true);
 
 
    }
}

Code:

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
class Liste extends JPanel{
	private static final long serialVersionUID = -4112048439060985533L;
	BufferedImage img  = new BufferedImage(512, 512, BufferedImage.OPAQUE);
	FileNameExtensionFilter filter;
    JButton jb = new JButton();
	File[] files;
	BufferedImage[] imgs;
 
    //constructeur
    public Liste()   {
 
    }
 
    public Liste(BufferedImage img, JButton jb, BufferedImage[] imgs) {
 
    }    
    public BufferedImage[] painter( File[] files) {
    	BufferedImage[] imgs = new BufferedImage[files.length];
        for(int i = 0; i < files.length; i++) {
            try{
               imgs[i] = ImageIO.read( files[i]  ) ;
            }
            catch (IOException e){
                e.printStackTrace();
            }
            setImgs(imgs);
            System.out.println("---"+imgs.length);
 
        }
 
return imgs;
 
 
    }    
	public BufferedImage[] getImgs() {
		return imgs;
	}
	public void setImgs(BufferedImage[] imgs) {
		this.imgs = imgs;
	}
 
	public void initcmp(BufferedImage img, JButton jb, File[] files) {
    	this.img = img;
		this.jb = jb;
		this.files = files;
		GridBagConstraints gbc = new GridBagConstraints(); gbc.gridx = 0;gbc.gridy = 0;
		gbc.weightx = 1;gbc.weighty = 1;
		this.setLayout(new GridBagLayout());
 
        this.add(jb, gbc);    	
        jb.addActionListener(e->new fchzzzz() ) ;
        if (files != null  ) 
        for(int i = 0; i < files.length; i++) {
            try{
               this.imgs[i] = ImageIO.read( files[i]  ) ;
            }
            catch (IOException e){
                e.printStackTrace();
            }    
        }        
    }
 
 
 
    public void loadImg(File[] fi )    {  
        for(int i = 0; i < fi.length; i++) {
            try{
               this.imgs[i] = ImageIO.read( fi[i]  ) ;
            }
            catch (IOException e){
                e.printStackTrace();
            }
         }     
    }
 
public void paintComponent(Graphics g) {
 
 
 
//	System.out.println("****" +this.files.length); //rien
		if (this.imgs !=null) {
		for ( int i =0; i<this.imgs.length;i++) {
			Graphics g2 = (Graphics2D)g;
         g2.drawImage(this.imgs[i],0,0, this.imgs[i].getWidth(),this.imgs[i].getHeight(), null);
 
		}
    }
}
}

Code:

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
class fchzzzz extends JFileChooser {
 
 
 
public fchzzzz() {	
 
 
        setMultiSelectionEnabled(true);
        setCurrentDirectory(new File("e:/01")); 
        setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
        isDirectorySelectionEnabled();
        FileNameExtensionFilter filter = new FileNameExtensionFilter
        ("imagesFormats", "jpg", "gif", "bmp","tga","tiff","jpeg", "png");
        setFileFilter(filter);
        Liste lst = new Liste();
 
        if (showOpenDialog(null) == JFileChooser.APPROVE_OPTION) {
        	File[] files;
        	File selected = getSelectedFile(); 
 
            if ( selected.isDirectory()  ) {            	 
           	 files = selected.getAbsoluteFile().listFiles();
           	 lst.initcmp(null, null, files);
 
            }
            else	if ( selected.isFile()  ) {       
            	 files = getSelectedFiles();            
               System.out.println(files.length);
             	 lst.painter(files);
            }
         }
	}
}

10/01/2022, 23h28
bouye

Hors besoin spécifique (animation, jeu vidéo) il n'y a pas besoin de faire une boucle de rafraîchissement actif dans Swing car... il y en a déjà une. Ce thread/cette boucle s'appelle l'EDT (Event Dispatch Thread). Cependant pour optimiser le rendu il y a des caches pour éviter de devoir redessiner ce qui n'a pas changé. Il faudrait donc penser a demander un repaint() si le contenu du composant a changé. C'est ce qui permettra au paintComponent() d’être invoqué par le gestionnaire d'affichage.

Par contre une optimisation future possible consisterai a charger les images dans une tache d’arrière plan (ex: SwingWorker) et ce pour éviter de geler l'EDT le temps que toutes les images soient chargées.