Splash Screen marche pas

Version imprimable

Bonjour a tous !

Voila j'ai un petit problème ... je charge un splash screen dans une main grâce à la méthode init() qui suis ... mais rien ne s'affiche dans la fenêtre, juste un rectangle gris ... j'ai essayé avec une JWindow et c'est pareil !

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
package clefs;
 
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Toolkit;
import javax.swing.*;
 
import javax.swing.border.EmptyBorder;
 
import com.swtdesigner.SwingResourceManager;
 
class Splash
{
    public static void init(String usrtype)
    {
        try
        {
            final JFrame splash = new JFrame();
            splash.setState(1);
            final JProgressBar progressBar = new JProgressBar();
            final JLabel splashImage = new JLabel();
            Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
            splashImage.setBackground(Color.BLUE);
            splashImage.setPreferredSize(new Dimension(640, 480));
            splashImage.setIcon(SwingResourceManager.getIcon(Splash.class, "splash.jpg"));
            splashImage.setBounds(0, 0, 640, 480);
            splashImage.setName("splashImage");
            splashImage.setMinimumSize(new Dimension(640, 480));
            splashImage.setMaximumSize(new Dimension(640, 480));
            splashImage.setIconTextGap(0);
            splashImage.setHorizontalTextPosition(SwingConstants.CENTER);
            splashImage.setHorizontalAlignment(SwingConstants.CENTER);
            splashImage.setFocusable(false);
            splashImage.setBorder(new EmptyBorder(0, 0, 0, 0));
            splashImage.setAlignmentX(Component.CENTER_ALIGNMENT);
            splashImage.setText("0");
            progressBar.setBounds(0, 480, 640, 20);
            progressBar.setStringPainted(true);
            splash.setIconImage(SwingResourceManager.getImage(Splash.class, "key.gif"));
            splash.getContentPane().setLayout(null);
            splash.setSize(640,500);
            splash.setUndecorated(true);
            splash.setTitle("Chargement ...");
            splash.setLocation(dim.width/2 - splash.getWidth()/2, dim.height/2 - splash.getHeight()/2);
            splash.setFocusable(false);
            splash.setVisible(true);
            splash.getContentPane().add(progressBar);
            splash.getContentPane().add(splashImage);
            Thread.sleep(4000);
            /*
             * Ici se trouve le chargement des tables du programme
             * 
             * Charger toutes les données grâce aux méthodes de VariableClass
             * 
             * Pour changer la chaîne qui s'affichera sur cette barre de chargement utiliser :
             * progressBar.setString("Chaîne de test ... changer ici");
             * 
             * Pour changer le pourcentage utiliser ça :
             * progressBar.setValue(100);  
             */
            splash.setVisible(false);
            FrmMain.init(usrtype);
 
        }
        catch (Exception e)
        {
            System.out.println("enclosing_package.enclosing_method : " + e);
        }
    }
}

Si quelqu'un peut m'aider ! Merci !

Je pense qu'il faut que tu dérive ta classe de Jwindow, voici un exemple qui intègre une image et une progress bar

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
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
 
public class SplashScreen extends JWindow {
 
    private BorderLayout mBorderLayout = new BorderLayout();
    private JLabel          mImageLabel    = new JLabel();
    private JPanel          mSouthPanel    = new JPanel();
    private JProgressBar mProgressBar    = new JProgressBar();
    private ClassLoader  mLoader           = getClass().getClassLoader();
 
    /**
     * This is the default constructor
     */
    public SplashScreen(ImageIcon imageIcon) {
        super();
        initialize(imageIcon);
    }
 
    public SplashScreen() {
        super();
        ImageIcon  theSplashImg = new ImageIcon(mLoader.getResource("img/osiris.png"));
        initialize(theSplashImg);
    }
 
    /**
     * This method initializes this
     * 
     * @return void
     */
    private void initialize(ImageIcon inImageIcon) {
        try {
            mImageLabel.setIcon(inImageIcon);
 
            int theWidth  = mImageLabel.getPreferredSize().width;
            mProgressBar.setPreferredSize(new Dimension(theWidth-10, 16));
 
            FlowLayout flowLayout = new FlowLayout();
            flowLayout.setVgap(2);
            flowLayout.setHgap(1);
 
            mSouthPanel.setBackground(Color.BLACK);
            mSouthPanel.setLayout(flowLayout);
            mSouthPanel.add(mProgressBar,null);
            mSouthPanel.setPreferredSize(new Dimension(theWidth, 22));
 
            this.getContentPane().setLayout(mBorderLayout);        
            this.getContentPane().add(mImageLabel, BorderLayout.CENTER);
            this.getContentPane().add(mSouthPanel, BorderLayout.SOUTH);
 
            this.pack();
            // Center the application on windows
            this.setLocationRelativeTo(this.getParent());
        }
        catch(Exception ex) {
            ex.printStackTrace();
        }
    }
 
    /**
     * This method define the maximum value of progressbar
     * 
     * @param  inMaxProgress Maximum value of proressbar
     * @return void
     */
    public void setProgressMax(int inMaxProgress)
    {
        mProgressBar.setMaximum(inMaxProgress);
    }
 
    /**
     * This method define the current value of progressbar
     * 
     * @param  inProgress define the current value of progressbar
     * @return void
     */
    public void setProgress(int inProgress)
    {
        final int theProgress = inProgress;
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                mProgressBar.setValue(theProgress);
            }
        });
    }
 
    /**
     * This method define the current value of progressbar
     * and add a message
     * 
     * @param  inMessage  Message to display under screen
     * @param  inProgress define the current value of progressbar
     * @return void
     */
    public void setProgress(String inMessage, int inProgress)
    {
        final int    theProgress = inProgress;
        final String theMessage  = inMessage;
        setProgress(inProgress);
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                mProgressBar.setValue(theProgress);
                setMessage(theMessage);
            }
        });
    }
 
    /**
     * This method define if the splashscreen is visible
     * 
     * @param  inDisplay
     * @return void
     */
    public void setScreenVisible(boolean inDisplay)
    {
        final boolean theDisplay = inDisplay;
        SwingUtilities.invokeLater(new Runnable() {
             public void run() {
                 setVisible(theDisplay);
             }
        });
    }
 
    /**
     * This method update the text displayed
     * 
     * @param  inMessage new message to display
     * @return void
     */
    private void setMessage(String inMessage)
    {
        if (inMessage==null) {
            inMessage = "";
            mProgressBar.setStringPainted(false);
        }
        else {
            mProgressBar.setStringPainted(true);
        }
        mProgressBar.setString(inMessage);
    }
}

pour l'utiliser, tu n'as plus qu'a l'appeler dans l'inititalisation de ton programme

Code:

1
2
3
4
5
6
7
8
 
mSplahScreen = new SplashScreen();
mSplahScreen.setScreenVisible(true);
 
       // code d'initialisation de l'aplication
 
mSplahScreen.setScreenVisible(false);
mSplahScreen = null;

Code:

1 2 3 4 5 6 7 8 SplashScreen screen = new SplashScreen("logo.jpg",false,true); screen.setBounds(300, 300, 700, 370); screen.setVisible(true); this.fillUser(this.jTextField1.getText()); this.authentificationOk(); screen.dispose(); screen=null; resetAuthentification();
j'ai également un problème avec cette méthode, il me semble pourtant bien faire comme indiqué, à savoir initialisation de mon splashscreen, initialisation de ma fenetre principale (sachant que ça dure 3 ou 4 secondes) et enfin je détruis ma splashscreen.

Mais voila comme je l'ai dit il y a problème, la splashscreen s'affiche vide avec comme image, le fond de l'ecran.

Lorsque je n'essaie pas d'initialiser ma fenetre principale, la splashscreen s'affiche très bien.

je pense qu'il y a une sorte de conflict entre les deux fenetres mais je n'arrive pas à le résoudre.

Quelqu'un a t il une idée ?

merci

01/08/2008, 00h30
bouye

Alors en survolant le code rapidement, je dirais que le probleme vient principalement du fait que tu executes tout ton code d'une traite dans la thread actuelle (l'EDT ?) avec un gros sleep() au milieu. Si cette thread est l'EDT ce qui semble etre le cas, cela veut dire que ton code se deroule entre deux reaffichage et donc il est normal que rien ou peu de chose ne s'affiche ; pire tu bloques l'EDT pendant 4 seconde donc ton image ne risque pas d'etre affichee a l'ecran entre temps.

Pour mieux faire, il te faut utiliser soit SwingUtilities.invokeLater(), soit un Timer Swing qui procedera a la construction de ta GUI puis a son affichage plus tard (eventuellement en plus d'une etape ce qui permet de faire bouger une eventuelle barre de progression) comme ca tu peux etre sur qu'il y aura des reaffichages entre temps.

Voila ça marche !!!

Pour ceux qui voudraient faire la même chose:

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
 
public class ThreadLoadingWindows extends Thread
{
    public void run() 
    {       
        try 
        {    
            SplashScreen screen = new SplashScreen("logo.jpg",true,true); 
            screen.setBounds(300,300, 700, 370); 
            screen.setVisible(true);
            Thread.sleep(500);
            screen.setProgressBarValue(25);
            Thread.sleep(1000);
            screen.setProgressBarValue(50);
            Thread.sleep(1000);
            screen.setProgressBarValue(75);
            Thread.sleep(1000);
            screen.setProgressBarValue(99);
            Thread.sleep(1000);
            screen.dispose();        
        }
        catch (Exception ex) 
        {
              ex.printStackTrace();
        }
    }
}

A noter que la class splashscreen n'est pas incluse de base dans java et qu'il faut la récupérer quelque part, c'est pas ça qui manque. Dans mon cas ma fenetre principal met environ 4 secondes à se charger, je simule ce chargement en incrémentant ma barre toutes les secondes.

Ensuite dans mon programme principal:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
  public void authentificationOk() 
    {   
        ThreadLoadingWindows t = new ThreadLoadingWindows();
 
        Thread principal = new Thread()
        {
              public void run() 
              {
                MainFrame mf = new MainFrame();
                mf.setVisible(true);
              }
        };
 
        t.start();
        principal.start();
    }

j'avais la flemme de recréer une autre classe etendue de thread, j'ai surcharger la méthode run directement dans la méthode appelée lorsque mon authentification de connexion est correct.

En tout cas merci pour le conseil de m'orienter vers les thread.

04/08/2008, 00h14
bouye

C'est bien, sauf que... il ne faut manipuler les fenetres et autres objets graphiques que durant l'EDT... donc il manque des SwingUtilities.invokeLater() pour rendre la chose Thread-safe un peu partout pour tout ce qui est maj de la GUI :fessee:.

;)
04/08/2008, 00h49
goingoin

Et donc concrètement comment dois je utiliser cette invokeLater ?
Je pensais bien que ce que j'ai fait n'est pas très conventionnel mais je n'ai pas cherché à palier à ces petits manques de sécurité puisque je ne me sers d'un thread que pour le spalshscreen.
Pour ma culture perso et pour bien faire la prochaine fois j'aimerais quand même bien savoir comment mieux faire. Si tu pouvais m'expliquer plus en détail ça serait simpa.

Merci

Grosso modo : partout ou tu manipules la GUI depuis ta Thread; donc, a priori, chacun des blocs rouges devraient etre execute dans son propre Runnable lance par SwingUtilities.invokeLater().
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 SplashScreen screen = new SplashScreen("logo.jpg",true,true); screen.setBounds(300,300, 700, 370); screen.setVisible(true); Thread.sleep(500); screen.setProgressBarValue(25); Thread.sleep(1000); screen.setProgressBarValue(50); Thread.sleep(1000); screen.setProgressBarValue(75); Thread.sleep(1000); screen.setProgressBarValue(99); Thread.sleep(1000); screen.dispose();
Quant a la ligne orange, bon normalement il faudrait l'executer durant l'EDT mais bon... tu as quand meme besoin d'avoir une reference sur ton screen (le declarer final pour pouvoir l'utiliser dans les Runnable anonymes) donc tu peux laisser comme ca sinon ca risque de te faire faire un peu plus de manip et de gestion de semaphores.

05/08/2008, 10h30
goingoin

Hum c'est encore des notions abstraites pour moi tout ça.
Je vais me documenter un peu plus et essayer ta proposition.

Merci