Discussion :

[speedster]

Bonjour,

Je me demandais s'il était possible de réaliser du texte qui défile automatiquement comme sur certains sites web.

Je suppose qu'il faut créer une thread pour cela mais après comment translater le texte et le replacer de l'autre côté

Si quelqu'un a des idées, je suis preneur.

[phil_ma]

Peux-tu préciser le contexte ?

[speedster]

Je dispose d'une barre de tâche qui est en réalité un jlabel en bas de ma fenêtre principale et j'aimerais que celle-ci affiche diverses informations en faisant défiler du texte de la droite vers la gauche.

[Nicolas_75]

Bonjour,

Ce n'est pas très dur à faire à la main.
Quelques ingrédients :
- une minuterie (Timer, TimerTask),
- faire attention aux indices pour découper la chaîne à afficher,
- une petite astuce (FontMetrics) pour connaître le nombre de caractères affichables.

Je me suis pris au jeu. Ci-dessous un exemple (avec un "main"), fait rapidement, donc très probablement améliorable.

Nicolas

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
// appeler le fichier JLabelTexteDefilant
// par nicolas_75
// 16 juillet 2005
 
import java.awt.*;
import javax.swing.*;
import java.util.Timer;
import java.util.TimerTask;
 
public class JLabelTexteDefilant extends JLabel {
 
    private final static int period = 1000; // fréquence de rafraichissement du JLabeln en ms
 
    private final static String space = "-"; // le caractère "espace", pour l'instant un trait d'union pour visualiser le défilement
    // à remplacer par un " "
 
    private String textToDisplay; // chaîne à afficher
    private int stringLength; // longueur de la chaîne à afficher
    private int nbColumns = -1; // nombre de colonnes du JLabel
    // -1 pour commencer : sera recalculé dès la première passe
    private int i = 0; // n° de la lettre de la String qui sera affichée au début du JLabel
    // si cette variable est égale à 3, le JLabel commencera avec la 3ème lettre de la String "texte à afficher" (par exemple), c'est-à-dire "te à afficher"
 
    // PRINCIPE
    // --
    //
    // (1) si stringLength < nbColumns
    // c'est-à-dire si la chaîne est plus petite que le JLabel
    // par exemple : "texte à afficher" (16) et un JLabel de 19
    // alors on fait défiler
    //
    // on commencer à i=0 : "texte à afficher---" (les "-" représentent des espaces"
    //    nb d'espaces à la fin : nbColumns-stringLength=3
    // puis i=-1 (comprendre : 1 espace au début) : "-texte à afficher--"
    //    nb d'espaces à la fin : nbColumns-stringLength+i=2
    // puis i=-2 (comprendre : 2 espaces au début) : "--texte à afficher-"
    //    nb d'espaces à la fin : nbColumns-stringLength+i=1
    // jusqu'à i=stringLength-nbColumns=-3 : "---texte à afficher"
    // ensuite on passe à i=stringLength-1 : "r---texte à affiche"
    //    c'est-à-dire string.substring(i) puis (nbColumns-stringLength) espaces
    //    puis string.substring(0,i)
    // puis on continue de baisser i
    // jusqu'à retrouver i=0
    //
    // (2) si stringLength >= nbColumns
    // c'est-à-dire si la chaîne (plus un espace) est plus grande que le JLabel
    // par exemple "texte à afficher (16) et un JLabel de 10
    // alors on ne fait pas défiler
 
    // constructeur
    public JLabelTexteDefilant(String textToDisplay) {
        // on suppose que la chaîne fait au moins 2 caractères : rajouter un test
        this.textToDisplay = textToDisplay;
        this.stringLength = this.textToDisplay.length();
    }
 
    public void start() {
        Timer timer = new Timer();
        TimerTask task = new TimerTask() {
            public void run() {
                JLabelTexteDefilant.this.nextStep();
            }
        };
        timer.scheduleAtFixedRate(task, 0, period);
    }
 
    public void nextStep() {
 
        // calculons le nombre de caractères affichables dans le JLabel
        // et vérifions qu'il n'a pas changé depuis la dernière fois
        int nbDisplayableSpaceCharacters = (this.getWidth() - this.getFontMetrics(this.getFont()).stringWidth(textToDisplay)) / this.getFontMetrics(this.getFont()).stringWidth(space);
        System.out.println(nbDisplayableSpaceCharacters);
        int newNbColumns = this.textToDisplay.length()+nbDisplayableSpaceCharacters;
        if (newNbColumns!=this.nbColumns) {
            this.nbColumns = newNbColumns;
            this.i=0;
        }
 
        // faisons défiler...
        StringBuffer sb = new StringBuffer();
        if (nbDisplayableSpaceCharacters>1){
            if (this.i==0) {
                sb.append(this.textToDisplay);
                for (int k=0; k<this.nbColumns-this.stringLength; k++) { sb.append(this.space); }
                this.setText(sb.toString());
                i--;
            } else if ((this.i<0) && (-this.i<=nbColumns-stringLength)) {
                for (int k=0; k<-this.i; k++) { sb.append(this.space); }
                sb.append(textToDisplay);
                for (int k=0; k<this.nbColumns-this.stringLength+this.i; k++) { sb.append(this.space); }
                this.setText(sb.toString());
                i--;
            } else if (-this.i==this.nbColumns-this.stringLength+1) {
                this.i = this.stringLength-1;
                this.nextStep();
 
            } else if (this.i>0) {
                sb.append(this.textToDisplay.substring(this.i));
                for (int k=0; k<this.nbColumns-this.stringLength; k++) { sb.append(this.space); }
                sb.append(textToDisplay.substring(0,this.i));
                this.setText(sb.toString());
                i--;
            } else {
                // ce cas ne doit pas arriver
                System.out.println("PROBLEME : cas inattendu"); // lancer une exception
            }
        } else { // on ne fait pas défiler
            this.setText(this.textToDisplay);
        }
 
    }
 
    // "main" de démonstration :
    public static void main(String[] args) {
        JFrame myFrame = new JFrame();
        myFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        myFrame.setSize(300, 300);
        myFrame.setLayout(new GridLayout(4,1));
        myFrame.add(new JLabel("Ci-dessous le JLabel défilant"));
        myFrame.add(new JLabel("Ne pas hésiter à redimensionner la fenêtre"));
        myFrame.add(new JLabel(" "));
        JLabelTexteDefilant myJLabelDefilant = new JLabelTexteDefilant("Ici le texte défilant, ici le texte défilant");
        myFrame.add(myJLabelDefilant);
        myFrame.setVisible(true);
        myJLabelDefilant.start();
    }
}

[herve91]

Pour compléter, voici un composant réalisant le défilement d'un texte dans un JLabel pixel par pixel, ou au gré de l'utilisateur (voir les différents constructeurs)

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
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.Timer;
import java.util.TimerTask;
 
public class JScrollingText extends JLabel {
 
    private int speed;
 
    private int period;
 
    private int offset;
 
    private int x;
 
    public JScrollingText(String text) {
        this(text, 1);
    }
 
    public JScrollingText(String text, int speed) {
        this(text, speed, 100);
    }
 
    public JScrollingText(String text, int speed, int period) {
        this(text, speed, period, 0);
    }
 
    public JScrollingText(String text, int speed, int period, int offset) {
        super(text);
        this.speed = speed;
        this.period = period;
        this.offset = offset;
    }
 
    public void paintComponent(Graphics g) {
        if (isOpaque()) {
            g.setColor(getBackground());
            g.fillRect(0, 0, getWidth(), getHeight());
        }
        g.setColor(getForeground());
 
        FontMetrics fm = g.getFontMetrics();
        Insets insets = getInsets();
 
        int width = getWidth() - (insets.left + insets.right);
        int height = getHeight() - (insets.top + insets.bottom);
 
        int textWidth = fm.stringWidth(getText());
        if (width < textWidth) {
            width = textWidth + offset;
        }
        x %= width;
 
        int textX = insets.left + x;
        int textY = insets.top + (height - fm.getHeight()) / 2  + fm.getAscent();
 
        g.drawString(getText(), textX, textY);
        g.drawString(getText(), textX + (speed > 0 ? -width : width), textY);
    }
 
    public void start() {
        Timer timer = new Timer();
        TimerTask task = new TimerTask() {
            public void run() {
                x += speed;
                repaint();
            }
        };
        timer.scheduleAtFixedRate(task, 0, period);
    }
 
    public static void main(String[] args) {
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(300, 200);
        JButton quit = new JButton("Quitter");
        quit.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                System.exit(0);
            }
        });
        frame.getContentPane().add(quit);
        JScrollingText scrollingText1 = new JScrollingText("Barre des tâches... Pressez le bouton Quitter", -3);
        scrollingText1.setBorder(BorderFactory.createEtchedBorder());
        scrollingText1.start();
        frame.getContentPane().add(scrollingText1, BorderLayout.NORTH);
        JScrollingText scrollingText2 = new JScrollingText("Barre des tâches... Pressez le bouton Quitter");
        scrollingText2.setBorder(BorderFactory.createEtchedBorder());
        scrollingText2.start();
        scrollingText2.setBackground(Color.YELLOW);
        scrollingText2.setOpaque(true);
        frame.getContentPane().add(scrollingText2, BorderLayout.SOUTH);
        frame.setVisible(true);
    }
}

[speedster]

Merci pour beaucoup pour ce code.

C'est tout à fait ce que je cherchais.
Néanmoins, je voudrais que le texte défile dans l'autre sens donc j'ai remplacé les i-- par les i++ mais ça ne suffit pas car j'obtiens une exception au bout d'un moment.

Enfin, je voulais savoir s'il était aussi possible de faire défiler du texte plus large que le label dans lequel il est affiché.

Merci d'avance.

PS : Je vais me replonger dans le code pour mieux le comprendre.

[speedster]

Je n'avais pas vu le deuxième code!

Celui-ci répond à mes questions!

Merci beaucoup pour vos réponses

[phil_ma]

super

pm