Page Sources Java libres - participez ici

Version imprimable

Voir 40 message(s) de cette discussion en une page

09/05/2008, 14h12
JackHack

1 pièce(s) jointe(s)

Webstart like

Auteur : JackHack
Titre : Applet se comportant comme Java Webstart

Bonjour voici une petite API qui permet depuis une Applet de lancer un jar éxécutable.
Comme Java webstart, elle copie en local vos jar et resources necessaires à votre application, puis lance votre application.
Mais en plus elle vous laisse la main libre sur la barre de progression de la copie.
Elle vous permet aussi de copiée des fichiers après le lancement.
Et elle évite de multiples boîte de dialogue de validation, une seule en fait est nécessaire, c'est la signature de l'Applet et c'est tout.

Bon j'ai tout mis dans le zip joins (documentation comprise ;) )

Jack Hack

comment transformer une date facon anglaise en francaise

il suffit de faire :
Code:

1 2 3 Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone("GMT+01:00"), Locale.FRANCE); Date date1=calendar.getTime(); String dateString=DateFormat.getDateInstance().format(date1);
Voila j'espère que ca servira car c'est un sujet frequament aborde

Comment vérifier qu'une adresse email exite par confirmation d'un message

Ce code utilise l'api java mail 1.3.

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
public void Confirmation(String email) throws Exception {
			String emailfrom = "Companier@Companie.fr";
			String emailto = email;
 
			// Récupére les propriétés du systéme
			Properties props = System.getProperties();
 
			// Spécification du serveur mail
			props.put("mail.smtp.host", "smtp.free.fr");
 
			// Récupère la session
			javax.mail.Session session = javax.mail.Session.getDefaultInstance(props, null);
 
			// Définition du message
			MimeMessage message = new MimeMessage(session);
			//Spécification de l'expéditeur
			try {
				message.setFrom(new InternetAddress(emailfrom));
			} catch (AddressException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (MessagingException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			//Spécification du destinataire
			try {
				message.addRecipient(Message.RecipientType.TO, new InternetAddress(emailto));
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				//throw exception;
			} 
			//Sujet du message
			try {
				message.setSubject("www.Companie.fr Utilisateurs");
			} catch (MessagingException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			//Texte du message on y introduit un lien hypertext appelant une servlet du cote serveur qui esr ConfirmationDemandeProjet
 
			String url = "http://www.Companie.fr/servlet/ConfirmationDemandeProjet?email="+email;
 
 
			String htmlText="<html><head><title>message.html</title>"+"<meta http-equiv=\"keywords\" content=\"keyword1,keyword2,keyword3\">"
			+"<meta http-equiv=\"description\" content=\"this is my page\"><meta http-equiv=\"content-type\" content=\"text/html; charset=ISO-8859-1\">"+
		    "<!--<link rel=\"stylesheet\" type=\"text/css\" href=\"./styles.css\">--></head><body><p>&nbsp;Merci de vous etes inscrit sur VisioClear.fr</p>"+
		  "<p>Votre adrese email est :"+email+"</p>"+
		  "<p>veuilliez cliquer sur ce lien pour confirmer votre demande de devis :<A HREF=\""+url +"\">ici</A></body></html>";

lorsque le client sérieux qui a bien donné son adresse email cliquera sur ici, la vérification sera faite par la servlet suivante ==>

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
public class ConfirmationDemandeProjet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
 
		HttpSession session = request.getSession(true);		  
		// Recupere l'email de l'utilisateur 
		String emailconfirmant = request.getParameter("email");
		System.out.println(emailconfirmant);
		PersonneDAO dao = new PersonneDAO();
		List candidatconfirme = dao.findByEmail(emailconfirmant);
 
		if (candidatconfirme.size()!=0) {
			Personne candidat = (Personne) candidatconfirme.get(0);
 
		candidat.setConfirme("oui");
 
 
		Transaction tx = dao.getSession().beginTransaction();
		dao.save(candidat);
		tx.commit();
		dao.getSession().close();
 
		EnregistrementSociete enr = new EnregistrementSociete();
		enr.confirmationMessage(candidat.getEmail());enr.confirmationMessageAdmin();
 
		getServletContext().getRequestDispatcher("/MaJSFCandidat.faces").forward(request,response);
		}
	}

Puis par persistance des données, on donne l'acces par candidat.setConfirme("oui").

Puis grace à

Code:

getServletContext().getRequestDispatcher("/MaJSFCandidat.jsp").forward(request,response);

on affiche pour le client qu'il est bien enregistrer.

Voila le fruit de longues recherches sur google, qui j'espère profitera pleinnement à ceux qui apprennent.

Pour comprendre le fonctionnement de java mail 1.3 voir http://www.supinfo-projects.com/fr/2004/javamail/ dans lequel j'ai puisser le code d'envoi de mail, mais le reste c'est bien moi qui l'ai fait :lol:

Vous avez le même processuse sur mon site http://www.visioclear.fr/
Mettez une vraie adresse email. et vous recevrez la demande de confirmation voila.

Bibliothèque : JMF (Multimédia)
Auteur : millie
Titre: Récuperation des données sur les pistes (audio/vidéo) d'un fichier multimédia avec JMF.

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
/**
 * 
 */
package media;
 
import java.io.IOException;
 
import javax.media.CannotRealizeException;
import javax.media.Format;
import javax.media.Manager;
import javax.media.MediaLocator;
import javax.media.NoPlayerException;
import javax.media.Processor;
import javax.media.control.TrackControl;
import javax.media.format.AudioFormat;
import javax.media.format.VideoFormat;
 
/**
 * @author millie
 * 
 */
public class Main {
 
	static boolean waitState(Processor processor, int state) {
		boolean transition = false;
		Object object = new Object();
 
		synchronized (object) {
			try {
				while (processor.getState() != state)
					object.wait(1000);
				transition = true;
			} catch (Exception e) {
			}
 
		}
 
		return transition;
	}
 
	/**
         * @param args
         * @throws IOException
         * @throws NoPlayerException
         * @throws CannotRealizeException
         */
	public static void main(String[] args) throws NoPlayerException,
			IOException, CannotRealizeException {
 
		MediaLocator mediaLocaltor = new MediaLocator(
				"file://C:/tmp/workspace/Media/video/test_ecoles.avi");
 
 
		Processor processor = Manager.createProcessor(mediaLocaltor);
 
		processor.realize();
		if (!waitState(processor, Processor.Realized)) {
			System.err.println("Failed");
			return;
		}
 
		double timeD = processor.getDuration().getSeconds();
 
		System.out.println("Durée : " + (int) timeD);
 
		System.out.println("Content descriptor : "
				+ processor.getContentDescriptor().toString());
 
		TrackControl[] tracks = processor.getTrackControls();
 
		for (int i = 0; i < tracks.length; i++) {
 
			Format format = tracks[i].getFormat();
			System.out.println(format.toString());
			if (format instanceof VideoFormat) {
				VideoFormat videoFormat = (VideoFormat) format;
				System.out.println("Video Format : ");
				System.out
						.println(" * Encoding : " + videoFormat.getEncoding());
				System.out.println(" * Framerate : "
						+ videoFormat.getFrameRate());
				System.out.println(" * Max data lenght : "
						+ videoFormat.getMaxDataLength());
				System.out.println(" * Size largeur : : "
						+ videoFormat.getSize().getWidth());
				System.out.println(" * Size hauteur : : "
						+ videoFormat.getSize().getHeight());
 
			}
 
			if (format instanceof AudioFormat) {
 
				System.out.println("Audio Format : ");
				AudioFormat audioFormat = (AudioFormat) format;
				System.out
						.println(" * Encoding : " + audioFormat.getEncoding());
				System.out
						.println(" * Channels : " + audioFormat.getChannels());
				System.out.println(" * FrameSizeInBits : "
						+ audioFormat.getFrameSizeInBits());
				System.out.println(" * Endian : " + audioFormat.getEndian());
				System.out.println(" * Signed : " + audioFormat.getSigned());
				System.out.println(" * SampleRate Hz : "
						+ audioFormat.getSampleRate());
				System.out.println(" s* SampleSizeInBit : "
						+ audioFormat.getSampleSizeInBits());
				System.out.println(" * FrameRate : "
						+ audioFormat.getFrameRate());
 
			}
 
		}
 
		processor.deallocate();
		processor.close();
		System.out.println("Fini");
 
	}
 
}

Pas mal cette dernière classe sur JMF millie, en voici une qui permet de lire n'importe quel fichier audio, pour peu d'avoir inclu les jars nécéssaires aux codecs.

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
 
/**
 * File AudioFileReader.java
 * Created on 30 mai 2008
 */
package util;
 
import java.io.File;
import java.io.IOException;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.SourceDataLine;
import javax.sound.sampled.UnsupportedAudioFileException;
 
/**
 *
 * @author Absil Romain.
 */
public class AudioFileReader
{
 
    public AudioFileReader()
    {
    }
 
    public static void readAudioFile(File file) 
            throws UnsupportedAudioFileException, IOException, 
                LineUnavailableException
    {
        AudioInputStream in = AudioSystem.getAudioInputStream(file);
        AudioInputStream din = null;
        AudioFormat baseFormat = in.getFormat();
        AudioFormat decodedFormat =
                new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
                baseFormat.getSampleRate(),
                16,
                baseFormat.getChannels(),
                baseFormat.getChannels() * 2,
                baseFormat.getSampleRate(),
                false);
        din = AudioSystem.getAudioInputStream(decodedFormat, in);
 
        rawplay(decodedFormat, din);
        in.close();
    }
 
    public static void rawplay(AudioFormat targetFormat, AudioInputStream din)
            throws IOException, LineUnavailableException
    {
        byte[] data = new byte[4096];
        SourceDataLine line = getLine(targetFormat);
        if (line != null)
        {
            // Start
            line.start();
            int nBytesRead = 0, nBytesWritten = 0;
            while (nBytesRead != -1)
            {
                nBytesRead = din.read(data, 0, data.length);
                if (nBytesRead != -1)
                    nBytesWritten = line.write(data, 0, nBytesRead);
            }
            // Stop
            line.drain();
            line.stop();
            line.close();
            din.close();
        }
    }
 
    public static SourceDataLine getLine(AudioFormat audioFormat)
            throws LineUnavailableException
    {
        SourceDataLine res = null;
        DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat);
        res = (SourceDataLine) AudioSystem.getLine(info);
        res.open(audioFormat);
        return res;
    }
}

Citation:

Envoyé par Razgriz

Pas mal cette dernière classe sur JMF millie, en voici une qui permet de lire n'importe quel fichier audio, pour peu d'avoir inclu les jars nécéssaires aux codecs.

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
 
/**
 * File AudioFileReader.java
 * Created on 30 mai 2008
 */
package util;
 
import java.io.File;
import java.io.IOException;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.SourceDataLine;
import javax.sound.sampled.UnsupportedAudioFileException;
 
/**
 *
 * @author Absil Romain.
 */
public class AudioFileReader
{
 
    public AudioFileReader()
    {
    }
 
    public static void readAudioFile(File file) 
            throws UnsupportedAudioFileException, IOException, 
                LineUnavailableException
    {
        AudioInputStream in = AudioSystem.getAudioInputStream(file);
        AudioInputStream din = null;
        AudioFormat baseFormat = in.getFormat();
        AudioFormat decodedFormat =
                new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
                baseFormat.getSampleRate(),
                16,
                baseFormat.getChannels(),
                baseFormat.getChannels() * 2,
                baseFormat.getSampleRate(),
                false);
        din = AudioSystem.getAudioInputStream(decodedFormat, in);
 
        rawplay(decodedFormat, din);
        in.close();
    }
 
    public static void rawplay(AudioFormat targetFormat, AudioInputStream din)
            throws IOException, LineUnavailableException
    {
        byte[] data = new byte[4096];
        SourceDataLine line = getLine(targetFormat);
        if (line != null)
        {
            // Start
            line.start();
            int nBytesRead = 0, nBytesWritten = 0;
            while (nBytesRead != -1)
            {
                nBytesRead = din.read(data, 0, data.length);
                if (nBytesRead != -1)
                    nBytesWritten = line.write(data, 0, nBytesRead);
            }
            // Stop
            line.drain();
            line.stop();
            line.close();
            din.close();
        }
    }
 
    public static SourceDataLine getLine(AudioFormat audioFormat)
            throws LineUnavailableException
    {
        SourceDataLine res = null;
        DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat);
        res = (SourceDataLine) AudioSystem.getLine(info);
        res.open(audioFormat);
        return res;
    }
}

Une version extraite des sources Audio donne une taille de buffer optimisée pour mettre dans le buffer 100ms à tous les coups :

Code:

1
2
3
		// 100 ms buffer for real time change to the sound stream
		int bufferSize = format.getFrameSize() * Math.round(format.getSampleRate() / 10);
		byte[] buffer = new byte[bufferSize];

J'avais vu ça là : http://java.developpez.com/sources/?...#echoJavasound

2 pièce(s) jointe(s)

Calculatrice à opérations simples

Cette contribution, toute modeste permet de comprendre quelques concepts de l’interface graphique en Java.
J’ai réalisé cette classe en m’inspirant du précieux document «Programmation Java pour les enfants, les parents et les grands-parents». J’ai trouvé intéressant de le compléter par ce programme qui consiste à réaliser une calculatrice à opérations simples. D’ailleurs un exemple de calculatrice a été expliqué dans ce tutoriel. Ce programme est en quelque sorte un complément de ce cas pratique.
J’espère que j’ai bien commenté les lignes de code pour que ce programme soit compris par des débutants et par tous ceux qui peuvent en trouver une piste ou quelconque solution à leurs développements…
Important : ne pas oublier de copier dans le même répertoire l'icone calculatrice.png ou de la créer. Cette icone est jointe dans ce document.

Titre : Calculatrice à opérations simples
Auteur : kmdkaci
Champ d'application : Interface graphique. Niveau : débutant

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
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
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
 
import javax.swing.*;
import java.awt.*;
import java.awt.event.*; //Pour les événements
 
public class Calculatrice extends JFrame  implements ActionListener
 
{
    JPanel pChiffre = new JPanel(); //Panel qui contient les chiffres
    JPanel pSigne = new JPanel();   //Panel des opérateurs (+/*-=)
    JPanel pSaisie = new JPanel(); //Panel pour le champ de saisie.
 
    //Declaration des bouttons
    JButton bUn = new  JButton("1");
    JButton bDeux = new  JButton("2");
    JButton bTrois = new  JButton("3");
    JButton bQuatre = new  JButton("4");
    JButton bCinq = new  JButton("5");
    JButton bSix = new  JButton("6");
    JButton bSept = new  JButton("7");
    JButton bHuit = new  JButton("8");
    JButton bNeuf = new  JButton("9");
    JButton bZero = new  JButton("0");
    JButton bPoint = new  JButton(".");
    JButton bEgal = new  JButton("=");
    JButton bMoins = new  JButton("-");
    JButton bPlus = new  JButton("+");
    JButton bFois = new  JButton("*");
    JButton bDiv = new  JButton("/");
    JButton bC = new  JButton("C");
    JButton bAbout = new JButton("?");
    TextField cSaisie = new TextField(20); //Zone de saisie
 
    JDialog aPropos = new JDialog(); //Boite A Propos de
 
    //Ce tableau sert à stocker les saisies
   //Entre les opérateurs et les chiffres, la taille doit être inférieure à 20 éléments
    //Vous pouvez bien sur modifier cette valeur.
    private String[] stocRes = new String[20];
 
    private int i = 0;
 
    static final int LARGEUR =  210;
    static final int LONGUEUR =  215;
 
    //cRes est une variable qui permet de stocker l’expression à évaluer
    private String cRes = "";
 
    //Prend Vraie si une erreur s'est produite
    private boolean erreur = false;
 
    public Calculatrice()
    {
      //On définit l'événement de fermeture de la fenêtre grâce à WindowAdapter
      WindowAdapter win = new WindowAdapter()
      {
        public void windowClosing(WindowEvent e)
        //Si on clique sur le bouton fermeture, on quitte le programme
        {System.exit(0);}
      };
 
      //On ajoute l'événement à notre fenêtre.
      addWindowListener(win);
 
        //On définit les événements pour les boutons.
        bUn.addActionListener(this);
        bDeux.addActionListener(this);
        bTrois.addActionListener(this);
        bQuatre.addActionListener(this);
        bCinq.addActionListener(this);
        bSix.addActionListener(this);
        bSept.addActionListener(this);
        bHuit.addActionListener(this);
        bNeuf.addActionListener(this);
        bPlus.addActionListener(this);
        bMoins.addActionListener(this);
        bDiv.addActionListener(this);
        bFois.addActionListener(this);
        bZero.addActionListener(this);
        bEgal.addActionListener(this);
        bC.addActionListener(this);
        bPoint.addActionListener(this);
        bAbout.addActionListener(this);
 
      //On appelle la fonction afficher
      afficher();
    }
 
     //Cette méthode permet de construire l'interface graphique
     public void afficher()
     {
        setSize(LARGEUR,LONGUEUR); //Fixer la taille
        setResizable(false); //Empêcher le redimensionnement de la fenêtre
        setTitle("Calculatrice");  //Titre de la fenêtre
        setLocationRelativeTo(null); //centrer la fenêtre
 
        //Déclaration de la fenêtre A propos
        JLabel label1 = new JLabel("                                 Developpez.com            ");
        JLabel label2 = new JLabel("                    Calculatrice à opèrations simples      ");
 
        //On affiche les labels sur deux 2 colonnes.
        //On définit le Layout comme GridLayout
        aPropos.getContentPane().setLayout(new GridLayout(2,1));
        aPropos.getContentPane().add(label1);
        aPropos.getContentPane().add(label2);
 
        //On fixe sa taille, son titre, empêcher le redimensionnement
        aPropos.setSize(320,150);
        aPropos.setTitle("A propos de ");
        aPropos.setResizable(false);
 
        //On l'affiche au milieu de l'écran
        aPropos.setLocationRelativeTo(null);
 
        //On associe à nos fenêtres une icone calculatrice.png (qui est dans le répertoire courant)
        Image icon = Toolkit.getDefaultToolkit().getImage(getClass().getClassLoader().getResource("./calculatrice.png"));
        setIconImage(icon);
 
        //On définit le conteneur pour la forme principale
        Container conteneur = getContentPane();
 
        //On lui fixe un BorderLayout. Dans la zone nord on affiche le champ de saisie
        //Au centre, on affiche les chiffres, et à l'est on affiche les opérateurs (signes).
        BorderLayout disposition = new BorderLayout();
        conteneur.setLayout(disposition);
 
        //On définit une font pour le champ de saisie.
       //On peut aussi laisser la font par défaut.
        Font font = new Font("TimesNewRoman",Font.BOLD,15);
        cSaisie.setFont(font );
 
        //On désactive le champ de saisie pour la saisie avec le clavier
        cSaisie.setEnabled(false);
 
        //On ajoute le champ cSaisie au panel pSaisie dans la partie nord du panel
        pSaisie.add(cSaisie);
        conteneur.add("North",pSaisie );
 
        //On ajoute les boutons des chiffres au panel pChiffre
        pChiffre.add(bUn);
        pChiffre.add(bDeux);
        pChiffre.add(bTrois);
        pChiffre.add(bQuatre);
        pChiffre.add(bCinq);
        pChiffre.add(bSix);
        pChiffre.add(bSept);
        pChiffre.add(bHuit);
        pChiffre.add(bNeuf);
        pChiffre.add(bZero);
        pChiffre.add(bPoint);
        pChiffre.add(bC);
        pChiffre.add(bAbout);
 
        //On définit le Layout de disposition pour pChiffre
        // 5 lignes et 3 colonnes, puis on ajoute le panel pChiffre dans la zone Centre du conteneur général
        GridLayout dispositionChiffres = new GridLayout(5, 3);
        pChiffre.setLayout(dispositionChiffres);
        conteneur.add("Center",pChiffre );
 
        //On ajoute les opérateurs au panel pSigne
        pSigne.add(bDiv);
        pSigne.add(bFois);
        pSigne.add(bMoins);
        pSigne.add(bPlus);
        pSigne.add(bEgal);
 
        //On lui definit la disposition GridLayout
        // soit à déposer en 5 ligne et une seule colonne
        GridLayout dispositionSignes = new GridLayout(5,1);
        pSigne.setLayout(dispositionSignes);
 
        //On ajoute pSigne à l'est du panel général
        conteneur.add("East",pSigne);
      }
 
       public void actionPerformed(ActionEvent evt)
          {
             String operateur = "+-*/"; //Les opérateurs
             String chiffres = "0123456789."; //Les chiffres
 
            //cas où on a appuyé sur un bouton chiffre
            //on cumule la saisie dans la variable cRes
            //Ex. si on a appuyé sur 2 puis sur 5, on aura la chaine "25"  dansla variable cRes
             if ( chiffres.indexOf(evt.getActionCommand()) != -1 )
             {
                  //X.indexOf(Y) renvoie la position de Y dans X, et renvoie -1 si Y ne se trouve pas dans X
                  cRes = cRes + evt.getActionCommand(); // getActionCommand donne le contenu du bouton.
                  cSaisie.setText(cRes); //On l'affiche
             }
 
             else  // Si le boutton de l'événement est un operateur
             if ( operateur.indexOf(evt.getActionCommand()) != -1 )
             {
                  //On stocke toute la chaine correspondante au chiffre saisie dans un élément du tableau
                  stocRes[i] = cRes;
                  i++; //On incremente l'indice
                  stocRes[i] = evt.getActionCommand(); //Puis on sauvegrade l'operateur
                  i++; //on avance dans le tableau
                  cRes = ""; //Puis on remis la variable qui stocke la chaine à vide.
             }
             else  //cas où on a appuyé sur le boutton =
             if ( evt.getActionCommand().equals("=") )
             {
                  double leResultat = 0;
                  //Cas particulier :
                  //Si on a rien saisi, on initialise la variable cRes à 0
                  if ( cRes.equals("") )
                  {
                    cRes = "0";
                  }
                  stocRes[i] = cRes;
                  i++;
 
                  //On calcule l'expression via la méthode calculer()
                  leResultat = calculer();
 
                  //S'il y a erreur on affiche le message Erreur comme résultat
                  if ( erreur )
                  {
                    cSaisie.setText("Erreur ");
                  }
                  else
                  { //Sinon on affiche la variable leResultat renvoyée par la fonction calculer()
                    cSaisie.setText(""+leResultat);
                  }
             }
             else
             //cas où on a appuyé sur le bouton 'C'
             if ( evt.getActionCommand().equals("C")  ) {
                  //On initialise cRes et on vide le tableau stocRes via la méthode vidertableau()
                  cRes = "0";
                  cSaisie.setText(cRes);
                  vidertableau();
             }
             else  //cas où on a appuyé sur le bouton '?'
                  //On affiche la boite A propos
             if ( evt.getActionCommand().equals("?") )
             {
                aPropos.setVisible(true);
             }
          }
 
          //Cette méthode évolue l'expression contenue dans le tableau stockRes
          public double calculer()
          {
            erreur = false; //Par défaut, il n y a pas d'erreur
            double resultat = 0;
            try
            {
            //On initialise le résultat au premier élément du tableau
            resultat = Double.parseDouble(stocRes[0]);
 
            //Si l'exception est rencontré la variable erreur est mise à true
            } catch(Exception e)
              {
                erreur = true;
                return 0;
              }
 
            // On parcoure le tableau et on procède comme suit pour évoluer l'expression :
            // soit cette expression à évoluer : 45+32-7
            // le résultat est initialisé au premier élément soit : 45, puis on rencontre un operateur (+) dans notre cas.
            // On somme la variable resultat avec stocRes[j+1], c'est à dire l'élément qui vient après l'operateur, soit 45+32
            // et on le met dans resultat, soit 77, puis on rencontre l'opérateur "-" et on évolue l'expréssion par (resultat - 7)
            // soit 77-7. et on met 70 dans la variable resultat.
            // l'opération varie bien sur selon l'operateur rencontré
             for(int j=0; j<= i-1; j++)
             {
                  try
                  {   //Opérateur + rencontré
                      if ( stocRes[j].equals("+") )
                      {
                        resultat = resultat + Double.parseDouble(stocRes [j+1]) ;
                        j++;
                      }else
                      //Opérateur - rencontré
                      if ( stocRes[j].equals("-") )
                      {
                        resultat = resultat - Double.parseDouble(stocRes [j+1]) ;
                        j++;
                      }else
                      //Opérateur * rencontré
                      if ( stocRes[j].equals("*") )
                      {
                        resultat = resultat * Double.parseDouble(stocRes [j+1]) ;
                        j++;
                      }else
                      //Opérateur / rencontré
                      if ( stocRes[j].equals("/") )
                      {
                        resultat = resultat / Double.parseDouble(stocRes [j+1]) ;
                        j++;
                      }
                  }catch (Exception e)
                    {
                      erreur = true; //Il ya une erreur quelques part, on initialise erreur à true
                      resultat = 0;
                      //Attention l'expression doit être correcte pour l'évaluer sans erreur
                    }
             }
             return resultat;
          }
 
          //Cette méthode vide le tableau stockRes
          public void vidertableau()
          {
              for ( int j = 0; j<= stocRes.length-1;j++ )
              {
                stocRes[j] = "";
                i=0;
              }
          }
 
    public static void main(String[] args)
     {
       new Calculatrice().setVisible(true);
     }
 
  }

16/10/2008, 23h12
ggorson

Méthode FillZéro
Une méthode super simple pour afficher un nombre sur un certain nombre de caractères et de remplir avec des zéros les caractères vides.

Exemple:

Citation:

Afficher 35 sur 6 caractères.

On doit obtenir « 000035 ».
Code:

1 2 3 4 public String fillZero(long i, int length){ return (length>Long.toString(i).length())?"0"+fillZero(i,length-1):Long.toString(i); }
La puissance des algorithmes récursifs et en une seule ligne!
Il y a d'autres méthodes, mais mon benchmark montre que c'est plus rapide.

http://www.genericsystem.com/web/act...ites/fill-zero
16/10/2008, 23h29
®om
Citation:
Envoyé par ggorson

Une méthode super simple pour afficher un nombre sur un certain nombre de caractères et de remplir avec des zéros les caractères vides.

Exemple:

Code:

1 2 3 4 public String fillZero(long i, int length){ return (length>Long.toString(i).length())?"0"+fillZero(i,length-1):Long.toString(i); }

La puissance des algorithmes récursifs et en une seule ligne!
Il y a d'autres méthodes, mais mon benchmark montre que c'est plus rapide.

http://www.genericsystem.com/web/act...ites/fill-zero
Une récursive en java avec concaténation de Strings, ça doit pas être le plus rapide? :D

Sérieusement, une méthode avec StringBuilder, ou meme remplir soi-même un tableau doit être bien plus rapide :)

Citation:

Envoyé par ggorson

La puissance des algorithmes récursifs et en une seule ligne!
Il y a d'autres méthodes, mais mon benchmark montre que c'est plus rapide.

Et qu'en est-il de celle-ci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
	public static String fillZero(long i, int length) {
		// On convertie en String de manière tout à fait normale :
		String str = Long.toString(i);
		final int strLen = str.length();
		// Si la chaine est plus courte que la taille voulu
		if (strLen<length) {
			// On crée un nouveau buffer à la taille voulu :
			final char[] cbuf = new char[length];
			// On remplaces les éléments manquants par des zéros :
			Arrays.fill(cbuf, 0, length-strLen, '0');
			// Et on recopies les chars de la chaine qu'on a créé :
			str.getChars(0, strLen, cbuf, length-strLen);
			// Juste avant de recréer une nouvelle String :
			str = new String(cbuf);
		}
		return str;
	}

:arrow: Pas de récursion (donc pas de multiplication des appels de méthodes, ni des variables temporaires).

a++

17/10/2008, 00h14
®om

Merci adiGuba, j'ai eu la flemme :D
17/10/2008, 15h31
ggorson

Citation:

Envoyé par adiGuba

Et qu'en est-il de celle-ci :
[...]
:arrow: Pas de récursion (donc pas de multiplication des appels de méthodes, ni des variables temporaires).

a++

J'ai refait mon benchmark en incluant ta méthode...
et le résultat est sans appel: elle est deux fois plus rapide. :roll::roll:

Voir le benchmark que j'ai publié ici 8-)

Merci adiGuba pour cette belle idée.
:lahola:
17/10/2008, 15h44
adiGuba

Citation:

Envoyé par ggorson

J'ai refait mon benchmark en incluant ta méthode...
et le résultat est sans appel: elle est deux fois plus rapide. :roll::roll:

En même temps, et même si elle doit être beaucoup moins performante (car beaucoup plus puissante), je préfères quand même de loin utiliser String.format() et sa syntaxe à la printf()...

Car une différence de quelques millisecondes sur près d'un million d'appel c'est vraiment négligeable dans la plupart des applications (à part si on fait des traitements intensives).

a++

JFrame plein écran

Salut,

voici une frame qui passe en plein écran et qui n'utilise pas le thread d'affichage d'awt. Ainsi vous pouvez faire du monotache plein écran (dit comme ça c'est peu engageant, mais pour faire du jeu vidéo c'est très pratique). Par défaut, Alt-F4 permet de quitter.

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
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
 
import java.awt.*;
import javax.swing.*;
import java.awt.image.*;
import java.awt.event.*;
 
public class FullScreenFrame extends JFrame {
 
  // Pour initialiser l'application
  public static void main(String[] args) {
    FullScreenFrame fsf = new FullScreenFrame();
    while (true)
      fsf.turn();
  }
 
  private static final int D_WIDTH = 1024;
  private static final int D_HEIGHT = 768;
  private static final int D_DEPTH = 32;
  private static final int BUFFERS = 3;
  private static final Cursor hiddenCursor = Toolkit.getDefaultToolkit().createCustomCursor(new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB), new Point() , "");
  private static final Cursor defaultCursor = new Cursor(Cursor.DEFAULT_CURSOR);
 
  private boolean close;
  private BufferStrategy buffStrat;
  private Rectangle drawBounds;
  private Cursor currentCursor;
  private KeyListener keyListener;
  private MouseListener mouseListener;
  private MouseMotionListener mouseMotionListener;
  private MouseWheelListener mouseWheelListener;
 
  // Constructeur avec paramètres par défaut
  public FullScreenFrame() {
    this(D_WIDTH, D_HEIGHT, D_DEPTH);
  }
 
  // Constructeur
  public FullScreenFrame(int width, int height, int depth) {
    super(""); // Le titre ne sera pas visible
    close = false; // Indicateur de fermeture de fenêtre : fenêtre ouverte
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Alt-F4 : quitter
    addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
        close = true; // Indicateur de fermeture de fenêtre : fermeture fenêtre
      }
    });
    setUndecorated(true); // Pas de bordures ni boutons
    setResizable(false); // Interdiction de changement de taille
    setFocusable(true); // Peut recevoir lengthfocus clavier
    setVisible(true); // Est visible
    setFocusTraversalKeysEnabled(false); // Recevoir les touches de gestion du focus (tab)
    requestFocus(); // Demander le focus clavier
    DisplayMode displayMode = getNearestCompatibleDisplayMode(width, height, depth); // Mode d'affichage le plus adapté
    setFullScreen(this, displayMode); // Passage en plein écran
    createBufferStrategy(BUFFERS); // Stratégie de gestion mémoire graphique : cycle de 3 buffers
    buffStrat = getBufferStrategy(); // Récupération de la stratégie de rafraîchissement
    drawBounds = getBounds(); // Zone affichable
    keyListener = new KeyAdapter() {}; // Gestion clavier
    mouseListener = new MouseAdapter() {}; // Gestion souris
    mouseMotionListener = new MouseMotionAdapter() {};
    mouseWheelListener = new MouseWheelListener() { public void mouseWheelMoved(MouseWheelEvent e){} };
    addKeyListener(keyListener);
    addMouseListener(mouseListener);
    addMouseMotionListener(mouseMotionListener);
    addMouseWheelListener(mouseWheelListener);
  }
 
  // Méthode pour gérer les paramètres de l'application
  public void live() {
  }
 
  // Méthode pour dessiner l'application
  public void draw(Graphics2D g, Rectangle r) {
    g.setColor(Color.pink);
    g.fill(r);
  }
 
  // Un tour de calculs pour la fenêtre et l'application associée
  public void turn() {
    live(); // calcul paramètres
    draw((Graphics2D)buffStrat.getDrawGraphics(), drawBounds); // affichage
    if ((!buffStrat.contentsLost()) && (!buffStrat.contentsRestored())) // si la mémoire graphique est correcte
      buffStrat.show(); // afficher lengthcontenu de la mémoire graphique
    if (close) // si fenêtre en cours de fermeture
      processClose(); // fermer
  }
 
  // fermeture de la fenêtre
  private void processClose() {
    setStartingDisplayMode(); // retour au mode d'affichage initial
    setCursor(null); // curseur par défaut
    dispose(); // libérer les ressources de la frame
    System.exit(0); // sortir
  }
 
// Affichage du curseur souris =================================================  
 
  public void setCursor(Cursor c) {
    if (c == currentCursor)
      return;
    super.setCursor(c);
    currentCursor = c;
  }
 
  public void hideCursor() {
    setCursor(hiddenCursor);
  }
 
  public void showCursor() {
    setCursor(defaultCursor);
  }
 
// Gestion des modes d'affichage et du plein écran =============================
 
  private static GraphicsDevice graphicsDevice = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
  private static DisplayMode startingDisplayMode = graphicsDevice.getDisplayMode();
  private static DisplayMode currentDisplayMode = graphicsDevice.getDisplayMode();
  private static DisplayMode[] availableDisplayModes = graphicsDevice.getDisplayModes();
  private static GraphicsConfiguration[] availableGraphicsConfigurations = graphicsDevice.getConfigurations();
 
  public static int getDefaultWidth() {
    return startingDisplayMode.getWidth();
  }
 
  public static int getDefaultHeight() {
    return startingDisplayMode.getHeight();
  }
 
  private static double getDefaultRatio() {
    return (double)getDefaultWidth() / (double)getDefaultHeight();
  }
 
  private static int getDefaultBitDepth() {
    return startingDisplayMode.getBitDepth();
  }
 
  public static DisplayMode getNearestCompatibleDisplayMode(int width, int height) {
    return getNearestCompatibleDisplayMode(width, height, getDefaultBitDepth());
  }
 
  public static DisplayMode getNearestCompatibleDisplayMode(int width, int height, int bitDepth) {
    return getNearestCompatibleDisplayMode(width, height, bitDepth, false);
  }
 
  private static DisplayMode getNearestCompatibleDisplayMode(int width, int height, int bitDepth, boolean keepRatio) {
    DisplayMode bestDisplayMode = startingDisplayMode;
    double ratio = getDefaultRatio();
 
    int dx = getDefaultWidth() - width;
    int dy = getDefaultHeight() - height;
    int d = Integer.MAX_VALUE;
    if ((dx >=0) && (dy >= 0))
      d = dx + dy;
    int bestD = d;
 
    int n = availableDisplayModes.length;
    DisplayMode dm;
    double r;
    for (int i = 0 ; i < n ; i++) {
      dm = availableDisplayModes[i];
      r = (double)dm.getWidth() / (double)dm.getHeight();
      if (((r == ratio) || (!keepRatio)) && (dm.getBitDepth() >= bitDepth)) {
        dx = dm.getWidth() - width;
        dy = dm.getHeight() - height;
        d = Integer.MAX_VALUE;
        if ((dx >=0) && (dy >= 0))
          d = dx + dy;
        if (d <= bestD) {
          bestDisplayMode = dm;
          bestD = d;
        }
      }
    }
    return bestDisplayMode;
  }
 
  public static boolean setFullScreen(Window wi, DisplayMode dm) {
    boolean ok = graphicsDevice.isFullScreenSupported();
    System.out.println("Full screen supported    : " + ok);
    if (ok)
      graphicsDevice.setFullScreenWindow(wi);
    else
      return false;
    ok = graphicsDevice.isDisplayChangeSupported();
    System.out.println("Display change supported : " + ok);
    if (ok) {
      try {
        graphicsDevice.setDisplayMode(dm);
      }
      catch (Exception e) {
        currentDisplayMode = startingDisplayMode;
        graphicsDevice.setDisplayMode(startingDisplayMode);
        graphicsDevice.setFullScreenWindow(null);
        return false;
      }
    }
    else
      return false;
    currentDisplayMode = dm;
    return true;
  }
 
  public static void setStartingDisplayMode() {
    if (currentDisplayMode == startingDisplayMode)
      return;
    currentDisplayMode = startingDisplayMode;
    graphicsDevice.setDisplayMode(startingDisplayMode);
    graphicsDevice.setFullScreenWindow(null);
  }
 
}

Pour un exemple d'utilisation, le classique Hello World remasterisé en Dolby Surround :

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
 
import java.awt.*;
import java.awt.event.*;
 
public class HelloWorld extends FullScreenFrame implements MouseMotionListener {
 
  public static void main(String[] args) {
    HelloWorld hello = new HelloWorld();
    while (true)
      hello.turn();
  }
 
  private int frames;
  private long startDate;
  private double fps;
  private int xMouse;
  private int yMouse;
 
  public HelloWorld() {
    super(640, 480, 32);
    frames = 0;
    startDate = System.currentTimeMillis();
 
    addMouseMotionListener(this);
//    hideCursor();
  }
 
  public void live() {
    frames++;
    fps = (double)frames * 1000d / (double)(System.currentTimeMillis() - startDate);
  }
 
  public void draw(Graphics2D g, Rectangle r) {
    super.draw(g,r);
    g.setColor(Color.blue);
    g.drawString("HELLO WORLD", r.width / 3, r.height / 3);
    g.drawString("(Alt-F4 pour quitter)", r.width / 3, r.height / 3 + 20);
    g.drawString("fps : " + fps, xMouse, yMouse);
    g.drawString("2009, Sylvain Tournois - http://sylv.tournois.free.fr/", 0, r.height - 33);
  }
 
  public void mouseMoved(java.awt.event.MouseEvent mouseEvent) {
    xMouse = mouseEvent.getX();
    yMouse = mouseEvent.getY();
  }
 
  public void mouseDragged(java.awt.event.MouseEvent mouseEvent) {
  }
 
}

Mini OS

Bonjour,

voici une des classes dont j'utilise le plus souvent les services dans mes projets. C'est un Mini-OS regroupant des services bien utiles :

- recherche de fichiers
- copie et création de fichiers
- effacement de fichiers
- deltree
- nettoyage de disque
- zip
- unzip

Le voici, il n'est pas très commenté mais très fonctionnel et disponible :

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
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
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
 
import java.io.*;
import java.util.*;
import java.text.*;
import java.util.zip.*;
 
public class MiniOS {
 
  // nettoie les disques c, d, e et f
  public static void main(String[] args) {
    String f0 = "monFichier.mp3"; // Un gros fichier (2 - 10 Mo)
    String f1 = "monFichier.jpg"; // Un fichier moyen (20 - 100 Ko)
    String f2 = "monFichier.txt"; // Un petit fichier (1 octet)
    cleanEmptySpaces("c", false, f0, f1, f2); // Remplit c:
    cleanEmptySpaces("d", false, f0, f1, f2); // Remplit d:
    cleanEmptySpaces("e", false, f0, f1, f2); // Remplit e:
    cleanEmptySpaces("f", false, f0, f1, f2); // Remplit f:
    delTree("c:\temp"); // Libère c:
    delTree("d:\temp"); // Libère d:
    delTree("e:\temp"); // Libère e:
    delTree("f:\temp"); // Libère f:
  }
 
  // nettoie un disque, si solo=true le répertoire temp est supprimé directement, 
  // sinon l'algorithme est plus efficace avec plusieurs lecteurs en faisant 
  // les effacements en groupé à la fin
  public static void cleanEmptySpaces(String diskLetter, boolean solo, String f0, String f1, String f2) {
    System.out.println("\nRC Pro __oPRo__ :\n=================\n\nScan de " + diskLetter + ":");
    String d = diskLetter + ":/temp";
    System.out.print("Ecrasemment :  ");
    String[] cs = {"\\", "|", "/", "-"};
    int i = 0;
    while (writeTempFile(f0, diskLetter)) {
      i++;
      System.out.print("\b" + cs[i % 4]);
    }
    while (writeTempFile(f1, diskLetter)) {
      i++;
      System.out.print("\b" + cs[i % 4]);
    }
    while (writeTempFile(f2, diskLetter)) {
      i++;
      System.out.print("\b" + cs[i % 4]);
    }
    System.out.println("\baplani.");
    if (solo)
      delTree(d);
  }
 
  // Copie un fichier dans le répertoire temp
  public static boolean writeTempFile(String sourceFile, String diskLetter) {
    return copyFile(sourceFile, diskLetter + ":/temp/FNEC_" + System.currentTimeMillis() + ".tmp", false);
  }
 
  // Copie un fichier src dans dst
  public static boolean copyFile(String src, String dst) {
    return copyFile(src, dst, true);
  }
 
  // Copie un fichier src dans dst, renvoie false si la copie a échoué
  public static boolean copyFile(String src, String dst, boolean verbose) {
    try {
      RandomAccessFile raf = new RandomAccessFile(src, "r");
      int n = (int)raf.length();
      byte[] data = new byte[n];
      raf.readFully(data);
      raf.close();
      createFile(dst);
      raf = new RandomAccessFile(dst, "rw");
      raf.setLength(0);
      raf.write(data);
      raf.close();
    }
    catch (Exception e) {
	  if (verbose)
        e.printStackTrace();
	  return false;
    }
	return true;
  }
 
  // Copie de src dans dst les fichiers *.*
  public static void copyDirectory(String src, String dst) {
    System.out.println("Copying tree " + src + " in " + dst);
    copyDirectory(src, dst, "*");
  }
 
  // Copie de src dans dst les fichiers *.extension
  public static void copyDirectory(String src, String dst, String ext) {
    copyDirectory(src, dst, "", ext);
  }
 
  // Copie de src dans dst les fichiers start*.extension
  public static void copyDirectory(String src, String dst, String start, String ext) {
    Vector v = getFileList(src, start, ext);
    int n = v.size();
    String s;
    String d;
    for (int i = 0 ; i < n ; i++) {
      s = (String)v.get(i);
      d = dst + s.substring(src.length());
      copyFile(s, d);
      printPercent(i, n);
    }
  }
 
  // Efface directory et son contenu
  public static void delTree(String directory) {
    System.out.println("Deleting tree " + directory);
    deleteFiles(directory, "*");
    deleteDirectory(directory);
  }
 
  // Efface *.* dans directory
  public static void deleteFiles(String directory) {
    deleteFiles(directory, "*");
  }
 
  // Efface *.extension dans directory
  public static void deleteFiles(String directory, String extension) {
    deleteFiles(directory, "", extension);
  }
 
  // Efface start*.extension dans directory
  public static void deleteFiles(String directory, String start, String extension) {
    System.out.println("Deleting " + directory + "/" + start + "*." + extension);
    File f;
    Vector v = getFileList(directory, start, extension);
    int n = v.size();
    for (int i = 0 ; i < n ; i++) {
      f = new File((String)v.get(i));
      f.delete();
      printPercent(i, n);
    }
  }
 
  // Efface un fichier
  public static void deleteFile(String s) {
    System.out.println("Deleting " + s);
    File f = new File(s);
    f.delete();
  }
 
  // Renvoie la liste des dossiers dans directory
  public static Vector getDirectoryList(String directory) {
    Vector result = new Vector();
    File f = new File(directory);
    File[] list = f.listFiles(new DirFileFilter());
    if ((list != null) && (list.length != 0))
      for (int i = 0 ; i < list.length ; i++)
        result.add(list[i].getName());
    return result;
  }
 
  // Renvoie la liste de *.extension dans directory
  public static Vector getFileList(String directory, String extension) {
    return getFileList(directory, "", extension);
  }
 
  // Renvoie la liste de start*.extension dans directory
  public static Vector getFileList(String directory, String start, String extension) {
    Vector result = new Vector();
    File f = new File(directory);
    File[] list = f.listFiles(new DirFileFilter());
    if ((list != null) && (list.length != 0))
      for (int i = 0 ; i < list.length ; i++)
        result.addAll(getFileList(f.getPath() + "\\" + list[i].getName(), extension));
    list = f.listFiles(new GenFileFilter(start, extension));
    String n;
    if ((list != null) && (list.length != 0))
      for (int i = 0 ; i < list.length ; i++) {
        n = reduceFileName(f.getPath() + "\\" + list[i].getName());
        result.add(n);
      }
    return result;
  }
 
  // Compression du dossier directory dans directory.zip
  public static void zip(String directory) {
    System.out.println("(c) 2009 Sylvain Tournois - www.anadoncamille.com");
    System.out.println("Archiving directory " + directory + " in file " + directory + ".zip :");
    try {
      FileOutputStream fos = new FileOutputStream(directory + ".zip");
      ZipOutputStream zos = new ZipOutputStream(fos);
      Vector entries = getFileList(directory, "*");
      int n = entries.size();
      String s;
      String s2;
      ZipEntry ze;
      RandomAccessFile raf = null;
      byte[] bb;
      int l = directory.length() + 1;
      for (int i = 0 ; i < n ; i++) {
        s = (String)entries.get(i);
//        System.out.print(" " + s.substring(Math.max(0, s.length() - 20), s.length()));
        s2 = s.substring(l);
        raf = new RandomAccessFile(s, "r");
        bb = new byte[(int)raf.length()];
        raf.read(bb);
        ze = new ZipEntry(s2);
        zos.putNextEntry(ze);
        zos.write(bb);
        raf.close();
        printPercent(i, n);
      }
      zos.finish();
      System.out.println("\nArchiving done. Thank you for using me!");
    }
    catch (Exception e) {
      e.printStackTrace();
    }
  }
 
  // Dézippe une archive archive.zip dans le dossier archive
  public static void unzip(String file) {
    try {
      String directory = file.substring(0, file.lastIndexOf(".")) + "/";
      System.out.println("(c) 2009 Sylvain Tournois - www.anadoncamille.com");
      System.out.println("Extracting file " + file + " in directory " + directory + " :");
      ZipFile zf = new ZipFile(file);
      ZipEntry ze;
      Hashtable ht = new Hashtable();
      int nf = 0;
      Enumeration e = zf.entries();
      for ( ; e.hasMoreElements() ; ) {
        ze = (ZipEntry)e.nextElement();
        ht.put(ze.getName(), ze);
        nf++;
      }
      RandomAccessFile raf = new RandomAccessFile(file, "r");
      byte[] bb = new byte[(int)raf.length()];
      raf.read(bb);
      raf.close();
      ByteArrayInputStream bais = new ByteArrayInputStream(bb);
      ZipInputStream zis = new ZipInputStream(bais);
      ze = zis.getNextEntry();
      String s;
      int i;
      int n;
      int l;
      int n2 = 0;
      while (ze != null) {
        ze = (ZipEntry)ht.get(ze.getName());
        s = directory + ze.getName();
        bb = new byte[(int)ze.getSize()];
        i = 0;
        l = bb.length;
        while (l > 0) {
          n = zis.read(bb, i, l);
          i += n;
          l -= n;
        }
        createFile(s);
        raf = new RandomAccessFile(s, "rw");
        raf.write(bb);
        raf.close();
        ze = zis.getNextEntry();
        printPercent(n2, nf);
        n2++;
      }
    }
    catch (Exception e) {
      e.printStackTrace();
    }
    System.out.println("\nExtracting done. Thank you for using me!");
  }
 
  // Simplifie un nom de fichier
  public static String reduceFileName(String s) {
    String s2 = s.replace('\\', '/');
    String[] words = s2.split("/");
    boolean[] ok = new boolean[words.length];
    for (int i = 0 ; i < words.length ; i++) 
      ok[i] = true;
    for (int i = words.length - 1 ; i >= 0 ; i--) {
      if (words[i].equals("..")) {
        int j = i - 1;
        while ((j >= 0) && ((words[j].equals("..")) || (!ok[j])))
          j--;
        if (j >= 0) {
          ok[i] = false;
          ok[j] = false;
        }
      }
    }
    s2 = "";
    for (int i = 0 ; i < words.length - 1 ; i++)
      if (ok[i])
        s2 += words[i] + "/";
    return s2 + words[words.length - 1];
  }
 
  // Crée un fichier et son chemin d'accès
  public static void createFile(String fileName) {
    if (fileName.indexOf('/') > 0) {
      File f = new File(fileName.substring(0, fileName.lastIndexOf('/')));
      f.mkdirs();
    }
    File f = new File(fileName);
    try {
      FileWriter fw = new FileWriter(fileName, false);
      fw.close();
    }
    catch (Exception e) {
    }
  }
 
  // Affiche un message de progression
  public static void printPercent(float step, float stepsCount) {
    float step_1 = step + 1;
    int percent = Math.round(step_1 * 100 / stepsCount);
    if (percent >= 100)
      percent = 99;
    String message = "" + percent + "%";
    if (percent < 10)
      message = " " + message; 
    if (step_1 >= stepsCount)
      message = "job done, " + (int)stepsCount + " steps.                                                     \n";
    else
      message = message + " - " + getHour() + " - step " + (int)(step_1) + "/" + (int)stepsCount;
    System.out.print("\r");
    if (step == 0)
      System.out.println("  " + getHour() + "  Starting job.");
    if (step_1 >= stepsCount)
      System.out.print("  " + getHour());
    System.out.print("  Working : " + message);
  }
 
  // Affiche l'heure
  public static String getHour() {
    return new SimpleDateFormat("HH:mm:ss").format(new Date());
  }
 
  // Efface l'arborescence des dossiers dans directory
  private static void deleteDirectory(String directory) {
    File f;
    Vector v = getDirectoryList(directory);
    int n = v.size();
    for (int i = 0 ; i < n ; i++)
      deleteDirectory(directory + "/" + (String)v.get(i));
    f = new File(directory);
    f.delete();
  }
 
  // Classe filtre pour fichiers
  private static class GenFileFilter implements FileFilter {
 
    private String start;
    private String extension;
    private boolean allFiles;
    private boolean allExts;
 
    public GenFileFilter(String ext) {
      start = "";
      extension = new String(ext);
      extension = extension.toLowerCase();
      allExts = extension.equals("*");
      allFiles = allExts;
    }
 
    public GenFileFilter(String s, String ext) {
      start = new String(s);
      start = start.toLowerCase();
      extension = new String(ext);
      extension = extension.toLowerCase();
      allExts = extension.equals("*");
      allFiles = allExts && start.equals("*");
    }
 
    public boolean accept(java.io.File file) {
      if (!file.isFile())
        return false;
      if (allFiles)
        return true;
 
 
 
      String n = file.getName();
      if (n.length() < start.length())
        return false;
      n = n.toLowerCase();
      String tst = n.substring(0, start.length());
      if (!tst.equals(start))
        return false;
      if (allExts)
        return true;
      if (n.lastIndexOf(".") < 0)
        return false;
      tst = n.substring(n.lastIndexOf(".") + 1, n.length());
      return tst.equals(extension);
    }
 
  }
 
  // Classe filtre pour répertoires
  private static class DirFileFilter implements FileFilter {
 
    public DirFileFilter() {
    }
 
    public boolean accept(java.io.File file) {
      return file.isDirectory();
    }
 
  }
 
}

L'accessoire de nettoyage de disque fait référence à la discussion suivante :
commande format et nettoyage disque dur

26/01/2009, 13h26
millie

Salut,

Tu ne veux pas plutôt dire que c'est un explorateur ?
26/01/2009, 13h38
sinok

Faudrait peut être éviter de localiser la classe sous windows, (par exemple pour la création du fichier temporaire).

Peut être propager les exceptions également.
26/01/2009, 17h04
anadoncamille

Citation:

Envoyé par millie

Tu ne veux pas plutôt dire que c'est un explorateur ?

Cela me ferait grand plaisir de l'appeler explorateur mais il n'en a que les fonctionnalités et aucune interface. En tout cas moyennant une interface, pour sûr il peut servir un explorateur.
Je l'ai appelé Mini OS en souvenir de ce bon vieux DOS.
Dans mon projet cette classe s'appelle KOS (K1000 OS).

Pour la localisation sous windows, cette localisation ne concerne que le nettoyeur de disque et est proposée en exemple d'utilisation. C'est facilement transposable en Linux ou Mac. Le reste des méthodes est non localisé. Pour la propagation des exceptions, je l'évite pour créer des méthodes tendant vers la gestion autonome, c'est à dire que dans la mesure du possible je traite les exceptions dans la méthode elle-même. C'est très rare que je propage les exceptions, mais c'est un choix de programmation parfaitement discutable.

Je vous donne Mini-OS telle que je l'utilise. Vous pouvez la modifier et l'améliorer pour qu'elle soit plus adaptée à vos besoins.

Citation:

Envoyé par anadoncamille

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
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
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
 
import java.io.*;
import java.util.*;
import java.text.*;
import java.util.zip.*;
 
public class MiniOS {
 
  // nettoie les disques c, d, e et f
  public static void main(String[] args) {
    String f0 = "monFichier.mp3"; // Un gros fichier (2 - 10 Mo)
    String f1 = "monFichier.jpg"; // Un fichier moyen (20 - 100 Ko)
    String f2 = "monFichier.txt"; // Un petit fichier (1 octet)
    cleanEmptySpaces("c", false, f0, f1, f2); // Remplit c:
    cleanEmptySpaces("d", false, f0, f1, f2); // Remplit d:
    cleanEmptySpaces("e", false, f0, f1, f2); // Remplit e:
    cleanEmptySpaces("f", false, f0, f1, f2); // Remplit f:
    delTree("c:\temp"); // Libère c:
    delTree("d:\temp"); // Libère d:
    delTree("e:\temp"); // Libère e:
    delTree("f:\temp"); // Libère f:
  }
 
  // nettoie un disque, si solo=true le répertoire temp est supprimé directement, 
  // sinon l'algorithme est plus efficace avec plusieurs lecteurs en faisant 
  // les effacements en groupé à la fin
  public static void cleanEmptySpaces(String diskLetter, boolean solo, String f0, String f1, String f2) {
    System.out.println("\nRC Pro __oPRo__ :\n=================\n\nScan de " + diskLetter + ":");
    String d = diskLetter + ":/temp";
    System.out.print("Ecrasemment :  ");
    String[] cs = {"\\", "|", "/", "-"};
    int i = 0;
    while (writeTempFile(f0, diskLetter)) {
      i++;
      System.out.print("\b" + cs[i % 4]);
    }
    while (writeTempFile(f1, diskLetter)) {
      i++;
      System.out.print("\b" + cs[i % 4]);
    }
    while (writeTempFile(f2, diskLetter)) {
      i++;
      System.out.print("\b" + cs[i % 4]);
    }
    System.out.println("\baplani.");
    if (solo)
      delTree(d);
  }
 
  // Copie un fichier dans le répertoire temp
  public static boolean writeTempFile(String sourceFile, String diskLetter) {
    return copyFile(sourceFile, diskLetter + ":/temp/FNEC_" + System.currentTimeMillis() + ".tmp", false);
  }
 
  // Copie un fichier src dans dst
  public static boolean copyFile(String src, String dst) {
    return copyFile(src, dst, true);
  }
 
  // Copie un fichier src dans dst, renvoie false si la copie a échoué
  public static boolean copyFile(String src, String dst, boolean verbose) {
    try {
      RandomAccessFile raf = new RandomAccessFile(src, "r");
      int n = (int)raf.length();
      byte[] data = new byte[n];
      raf.readFully(data);
      raf.close();
      createFile(dst);
      raf = new RandomAccessFile(dst, "rw");
      raf.setLength(0);
      raf.write(data);
      raf.close();
    }
    catch (Exception e) {
	  if (verbose)
        e.printStackTrace();
	  return false;
    }
	return true;
  }
 
  // Copie de src dans dst les fichiers *.*
  public static void copyDirectory(String src, String dst) {
    System.out.println("Copying tree " + src + " in " + dst);
    copyDirectory(src, dst, "*");
  }
 
  // Copie de src dans dst les fichiers *.extension
  public static void copyDirectory(String src, String dst, String ext) {
    copyDirectory(src, dst, "", ext);
  }
 
  // Copie de src dans dst les fichiers start*.extension
  public static void copyDirectory(String src, String dst, String start, String ext) {
    Vector v = getFileList(src, start, ext);
    int n = v.size();
    String s;
    String d;
    for (int i = 0 ; i < n ; i++) {
      s = (String)v.get(i);
      d = dst + s.substring(src.length());
      copyFile(s, d);
      printPercent(i, n);
    }
  }
 
  // Efface directory et son contenu
  public static void delTree(String directory) {
    System.out.println("Deleting tree " + directory);
    deleteFiles(directory, "*");
    deleteDirectory(directory);
  }
 
  // Efface *.* dans directory
  public static void deleteFiles(String directory) {
    deleteFiles(directory, "*");
  }
 
  // Efface *.extension dans directory
  public static void deleteFiles(String directory, String extension) {
    deleteFiles(directory, "", extension);
  }
 
  // Efface start*.extension dans directory
  public static void deleteFiles(String directory, String start, String extension) {
    System.out.println("Deleting " + directory + "/" + start + "*." + extension);
    File f;
    Vector v = getFileList(directory, start, extension);
    int n = v.size();
    for (int i = 0 ; i < n ; i++) {
      f = new File((String)v.get(i));
      f.delete();
      printPercent(i, n);
    }
  }
 
  // Efface un fichier
  public static void deleteFile(String s) {
    System.out.println("Deleting " + s);
    File f = new File(s);
    f.delete();
  }
 
  // Renvoie la liste des dossiers dans directory
  public static Vector getDirectoryList(String directory) {
    Vector result = new Vector();
    File f = new File(directory);
    File[] list = f.listFiles(new DirFileFilter());
    if ((list != null) && (list.length != 0))
      for (int i = 0 ; i < list.length ; i++)
        result.add(list[i].getName());
    return result;
  }
 
  // Renvoie la liste de *.extension dans directory
  public static Vector getFileList(String directory, String extension) {
    return getFileList(directory, "", extension);
  }
 
  // Renvoie la liste de start*.extension dans directory
  public static Vector getFileList(String directory, String start, String extension) {
    Vector result = new Vector();
    File f = new File(directory);
    File[] list = f.listFiles(new DirFileFilter());
    if ((list != null) && (list.length != 0))
      for (int i = 0 ; i < list.length ; i++)
        result.addAll(getFileList(f.getPath() + "\\" + list[i].getName(), extension));
    list = f.listFiles(new GenFileFilter(start, extension));
    String n;
    if ((list != null) && (list.length != 0))
      for (int i = 0 ; i < list.length ; i++) {
        n = reduceFileName(f.getPath() + "\\" + list[i].getName());
        result.add(n);
      }
    return result;
  }
 
  // Compression du dossier directory dans directory.zip
  public static void zip(String directory) {
    System.out.println("(c) 2009 Sylvain Tournois - www.anadoncamille.com");
    System.out.println("Archiving directory " + directory + " in file " + directory + ".zip :");
    try {
      FileOutputStream fos = new FileOutputStream(directory + ".zip");
      ZipOutputStream zos = new ZipOutputStream(fos);
      Vector entries = getFileList(directory, "*");
      int n = entries.size();
      String s;
      String s2;
      ZipEntry ze;
      RandomAccessFile raf = null;
      byte[] bb;
      int l = directory.length() + 1;
      for (int i = 0 ; i < n ; i++) {
        s = (String)entries.get(i);
//        System.out.print(" " + s.substring(Math.max(0, s.length() - 20), s.length()));
        s2 = s.substring(l);
        raf = new RandomAccessFile(s, "r");
        bb = new byte[(int)raf.length()];
        raf.read(bb);
        ze = new ZipEntry(s2);
        zos.putNextEntry(ze);
        zos.write(bb);
        raf.close();
        printPercent(i, n);
      }
      zos.finish();
      System.out.println("\nArchiving done. Thank you for using me!");
    }
    catch (Exception e) {
      e.printStackTrace();
    }
  }
 
  // Dézippe une archive archive.zip dans le dossier archive
  public static void unzip(String file) {
    try {
      String directory = file.substring(0, file.lastIndexOf(".")) + "/";
      System.out.println("(c) 2009 Sylvain Tournois - www.anadoncamille.com");
      System.out.println("Extracting file " + file + " in directory " + directory + " :");
      ZipFile zf = new ZipFile(file);
      ZipEntry ze;
      Hashtable ht = new Hashtable();
      int nf = 0;
      Enumeration e = zf.entries();
      for ( ; e.hasMoreElements() ; ) {
        ze = (ZipEntry)e.nextElement();
        ht.put(ze.getName(), ze);
        nf++;
      }
      RandomAccessFile raf = new RandomAccessFile(file, "r");
      byte[] bb = new byte[(int)raf.length()];
      raf.read(bb);
      raf.close();
      ByteArrayInputStream bais = new ByteArrayInputStream(bb);
      ZipInputStream zis = new ZipInputStream(bais);
      ze = zis.getNextEntry();
      String s;
      int i;
      int n;
      int l;
      int n2 = 0;
      while (ze != null) {
        ze = (ZipEntry)ht.get(ze.getName());
        s = directory + ze.getName();
        bb = new byte[(int)ze.getSize()];
        i = 0;
        l = bb.length;
        while (l > 0) {
          n = zis.read(bb, i, l);
          i += n;
          l -= n;
        }
        createFile(s);
        raf = new RandomAccessFile(s, "rw");
        raf.write(bb);
        raf.close();
        ze = zis.getNextEntry();
        printPercent(n2, nf);
        n2++;
      }
    }
    catch (Exception e) {
      e.printStackTrace();
    }
    System.out.println("\nExtracting done. Thank you for using me!");
  }
 
  // Simplifie un nom de fichier
  public static String reduceFileName(String s) {
    String s2 = s.replace('\\', '/');
    String[] words = s2.split("/");
    boolean[] ok = new boolean[words.length];
    for (int i = 0 ; i < words.length ; i++) 
      ok[i] = true;
    for (int i = words.length - 1 ; i >= 0 ; i--) {
      if (words[i].equals("..")) {
        int j = i - 1;
        while ((j >= 0) && ((words[j].equals("..")) || (!ok[j])))
          j--;
        if (j >= 0) {
          ok[i] = false;
          ok[j] = false;
        }
      }
    }
    s2 = "";
    for (int i = 0 ; i < words.length - 1 ; i++)
      if (ok[i])
        s2 += words[i] + "/";
    return s2 + words[words.length - 1];
  }
 
  // Crée un fichier et son chemin d'accès
  public static void createFile(String fileName) {
    if (fileName.indexOf('/') > 0) {
      File f = new File(fileName.substring(0, fileName.lastIndexOf('/')));
      f.mkdirs();
    }
    File f = new File(fileName);
    try {
      FileWriter fw = new FileWriter(fileName, false);
      fw.close();
    }
    catch (Exception e) {
    }
  }
 
  // Affiche un message de progression
  public static void printPercent(float step, float stepsCount) {
    float step_1 = step + 1;
    int percent = Math.round(step_1 * 100 / stepsCount);
    if (percent >= 100)
      percent = 99;
    String message = "" + percent + "%";
    if (percent < 10)
      message = " " + message; 
    if (step_1 >= stepsCount)
      message = "job done, " + (int)stepsCount + " steps.                                                     \n";
    else
      message = message + " - " + getHour() + " - step " + (int)(step_1) + "/" + (int)stepsCount;
    System.out.print("\r");
    if (step == 0)
      System.out.println("  " + getHour() + "  Starting job.");
    if (step_1 >= stepsCount)
      System.out.print("  " + getHour());
    System.out.print("  Working : " + message);
  }
 
  // Affiche l'heure
  public static String getHour() {
    return new SimpleDateFormat("HH:mm:ss").format(new Date());
  }
 
  // Efface l'arborescence des dossiers dans directory
  private static void deleteDirectory(String directory) {
    File f;
    Vector v = getDirectoryList(directory);
    int n = v.size();
    for (int i = 0 ; i < n ; i++)
      deleteDirectory(directory + "/" + (String)v.get(i));
    f = new File(directory);
    f.delete();
  }
 
  // Classe filtre pour fichiers
  private static class GenFileFilter implements FileFilter {
 
    private String start;
    private String extension;
    private boolean allFiles;
    private boolean allExts;
 
    public GenFileFilter(String ext) {
      start = "";
      extension = new String(ext);
      extension = extension.toLowerCase();
      allExts = extension.equals("*");
      allFiles = allExts;
    }
 
    public GenFileFilter(String s, String ext) {
      start = new String(s);
      start = start.toLowerCase();
      extension = new String(ext);
      extension = extension.toLowerCase();
      allExts = extension.equals("*");
      allFiles = allExts && start.equals("*");
    }
 
    public boolean accept(java.io.File file) {
      if (!file.isFile())
        return false;
      if (allFiles)
        return true;
 
 
 
      String n = file.getName();
      if (n.length() < start.length())
        return false;
      n = n.toLowerCase();
      String tst = n.substring(0, start.length());
      if (!tst.equals(start))
        return false;
      if (allExts)
        return true;
      if (n.lastIndexOf(".") < 0)
        return false;
      tst = n.substring(n.lastIndexOf(".") + 1, n.length());
      return tst.equals(extension);
    }
 
  }
 
  // Classe filtre pour répertoires
  private static class DirFileFilter implements FileFilter {
 
    public DirFileFilter() {
    }
 
    public boolean accept(java.io.File file) {
      return file.isDirectory();
    }
 
  }
 
}

L'accessoire de nettoyage de disque fait référence à la discussion suivante :
commande format et nettoyage disque dur

vous avez utilisez monfichier.txt de 1 octet cad un fichier mais pour le cas de un dossier qui contient de plus de 1000 fichier .txt j'arrive pas a le ouvrir ,par la méthode ouvrire suivanteje peut ouvrir un seule fichier.txt :

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
void ouvrir(){
          String path = new String("");
jFileChooser jFileChooser1 = new jFileChooser();
 
 
 
           if (JFileChooser.APPROVE_OPTION == jFileChooser1.showOpenDialog(this)) {
               path = jFileChooser1.getSelectedFile().getPath();
           }
           try {this.setTitle("ouvrir une Corpus de text -"+path);
               File file = new File(path);
               int size = (int) file.length();
               int chars_read = 0;
               FileReader in = new FileReader(file);
               char[] data = new char[size];
               while (in.ready()) {
                   chars_read += in.read(data, chars_read, size - chars_read);
               }
               in.close();
               aaaa = new String(data, 0, chars_read);
               jTextArea5.append(aaaa);
               } catch (IOException E) {
           }
 
     }

si vous pouvez me proposé une nouvelle idé ou une petite amélioration je serais trés ravis

02/02/2009, 00h29
anadoncamille

Lecteur de fichiers texte
Bonjour kamilia_85,

Pour ouvrir et lire un fichier texte, vous pouvez utiliser la classe sur le lien suivant : Lecteur de fichiers textes.
Cette classe vous permettra de lire tous les fichiers de votre dossier, quel que soit leur nombre.

Le code swing que vous utilisez permet de sélectionner les fichiers à ouvrir un par un. Si vous voulez ouvrir plusieurs fichiers en même temps, vous devez utiliser un algorithme de recherche fonctionnant comme la commande DOS

Code:

dir *.txt

et vous pourrez utiliser les méthodes de recherche de fichier du Mini-OS pour déterminer la liste des fichiers à ouvrir.
Code:

1 2 3 4 5 6 7 8 Vector listeFichiers = MiniOS.getFileList("monDossier", "txt"); String fichier; for (int n = 0 ; i < listeFichiers.size() ; i++) { fichier = (String)v.get(i); ... votre code ; }
Votre fenêtre de choix de fichier pourra vous servir à décider quels fichiers vous voulez lire (*.txt, *.doc, etc...)

1 pièce(s) jointe(s)

problème utilisation classes fournies

Citation:

Envoyé par Razgriz

Voici un dernier encrypteur (je commence à faire ch*** avec mes encrypteurs je sais lol), qui utilise cette fois un chifrement non-symétrique, et qui est également très performant. L'inconvéniant d'un tel algorithme (non symétrique) est qu'il possède une complexité assez élevée (i.e. il va tourner beaucoup plus lentement pour de grandes quantités de données qu'un algorihme symétrique), et donc qu'il est peu pratique à utilsier dans ce cas, mais une petite asctuce permet de s'en sortir facilement de combinaisaond e cryptage symétriques et non symétriques permet d'utiliser efficacement l'algorithme.

J'utilise pour l'encrypteur suivant l'algorithme RSA, inventé par Rivest, Shamir et Eddleman.

[EDIT]
Dernière mise à jour le 16/10/2007 (modélisatio et sécurité). Vous avez besoin des classes FileEncryptor et CipherEcryptor pour la faire fonctionner.
[/EDIT]

Le voici :

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
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
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
 
/*
 * RSAEncryptor.java
 *
 * Created on 17 juin 2006, 15:58
 * 
 */
 
package org.cosmopol.crypto;
 
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.util.ArrayList;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.ShortBufferException;
import javax.crypto.BadPaddingException;
 
/**
 * This class provides methods to generate keys, encrypt or decrypt files and
 * streams with the RSA crypting algorithm.
 * @author Absil Romain
 */
public class RSAEncryptor extends FileEncryptor
{
    private Key publicKey;
    private Key privateKey;
    private boolean isEncryptInitialized;
    private boolean isDecryptInitialized;
 
    /**
     * Constructs a new RSA encryptor with the specified file containing one 
     * of the keys, in encrypt or decrypt mode (depends on the type of stored
     * key, if the key is public, then the encryptor is in encrypt mode,
     * otherwise it is in decrypt mode.
     * @param keyFileName the name of the file containing a RSA key.
     * @throws java.io.FileNotFoundException if the file containing the key doesn't
     * exist.
     * @throws java.io.IOException if an error occurs during reading the file 
     * containing the key.
     * @throws java.lang.ClassNotFoundException if the class of the key is unknown.
     * @throws java.security.InvalidKeyException is the stored key is not a valid type of key.
     */
    public RSAEncryptor(String keyFileName) 
        throws FileNotFoundException, IOException, ClassNotFoundException, 
            InvalidKeyException
    {
        ObjectInputStream keyIn = new ObjectInputStream(
                new FileInputStream(keyFileName));
        Object key = keyIn.readObject();
        keyIn.close();
 
        if(key instanceof PublicKey)
        {
            publicKey = (Key)key;
            isEncryptInitialized = true;
        }
        else if(key instanceof PrivateKey)
        {
            privateKey = (Key)key;
            isDecryptInitialized = true;
        }
        else
            throw new InvalidKeyException("The file does not contain a " +
                    "valid key");
    }
 
    /**
     * Constructs a new RSA encryptor with the specified file containing one 
     * of the keys, in encrypt or decrypt mode (depends on the type of stored
     * key, if the key is public, then the encryptor is in encrypt mode,
     * otherwise it is in decrypt mode.
     * @param keyFile the file containing a RSA key.
     * @throws java.io.FileNotFoundException if the file containing the key doesn't
     * exist.
     * @throws java.io.IOException if an error occurs during reading the file 
     * containing the key.
     * @throws java.lang.ClassNotFoundException if the class of the key is unknown.
     * @throws java.security.InvalidKeyException is the stored key is not a valid type of key.
     */
    public RSAEncryptor(File keyFile) 
        throws FileNotFoundException, IOException, ClassNotFoundException, InvalidKeyException
    {
        ObjectInputStream keyIn = new ObjectInputStream(
                new FileInputStream(keyFile));
        Object key = keyIn.readObject();
        keyIn.close();
 
        if(key instanceof PublicKey)
        {
            publicKey = (Key)key;
            isEncryptInitialized = true;
        }
        else if(key instanceof PrivateKey)
        {
            privateKey = (Key)key;
            isDecryptInitialized = true;
        }
        else
            throw new InvalidKeyException("The file does not contain a " +
                    "valid key");
    }
 
    /**
     * Constructs a new RSA encryptor in encrypt mode with the specified
     * public key.
     * @param key the public key (used to encrypt files and streams).
     **/
    public RSAEncryptor(PublicKey key)
    {
        this.publicKey = key;
        this.isEncryptInitialized = true;
    }
 
    /**
     * Constructs a new RSA encryptor in decrypt mode with the specified
     * private key.
     * @param key the private key (used to decrypt files and streams).
     **/
    public RSAEncryptor(PrivateKey key)
    {
        this.privateKey = key;
        this.isDecryptInitialized = true;
    }
 
    /**
     * Constructs a new RSA encryptor in encrypt and decrypt mode with the
     * specified files containing the public and private key.
     * @param publicKeyFileName the name of the file containing the public key.
     * @param privateKeyFileName the name of the file containing the private key.
     * @throws java.io.FileNotFoundException if one of the files containing a key 
     * doen't exist.
     * @throws java.io.IOException if an error occurs during reading one of the keys.
     * @throws java.lang.ClassNotFoundException if one of the class of the keys is
     * unknown.
     * @throws java.security.InvalidKeyException if the files containing the keys don't
     * contain valid keys.
     */
    public RSAEncryptor(String publicKeyFileName, String privateKeyFileName) 
        throws FileNotFoundException, IOException, ClassNotFoundException,
            InvalidKeyException
    {
        ObjectInputStream keyIn = new ObjectInputStream(
                new FileInputStream(publicKeyFileName));
        Object puKey = keyIn.readObject();
        keyIn.close();
 
        keyIn = new ObjectInputStream(
                new FileInputStream(privateKeyFileName));
        Object prKey = keyIn.readObject();
        keyIn.close();
 
        if(puKey instanceof PublicKey && prKey instanceof PrivateKey)
        {
            this.publicKey = (Key)puKey;
            this.isEncryptInitialized = true;
            this.privateKey = (Key)prKey;
            this.isDecryptInitialized = true;
        }
        else
            throw new InvalidKeyException("Some of the files don't contains" +
                    " a valid key");
    }
 
    /**
     * Constructs a new RSA encryptor in encrypt and decrypt mode with the
     * specified files containing the public and private key.
     * @param publicKeyFile the file containing the public key.
     * @param privateKeyFile the file containing the private key.
     * @throws java.io.FileNotFoundException if one of the files containing a key 
     * doen't exist.
     * @throws java.io.IOException if an error occurs during reading one of the keys.
     * @throws java.lang.ClassNotFoundException if one of the class of the keys is
     * unknown.
     */
    public RSAEncryptor(File publicKeyFile, File privateKeyFile) 
        throws FileNotFoundException, IOException, ClassNotFoundException
    {
        ObjectInputStream keyIn = new ObjectInputStream(
                new FileInputStream(publicKeyFile));
        this.publicKey = (Key) keyIn.readObject();
        this.isEncryptInitialized = true;
        keyIn.close();
 
        keyIn = new ObjectInputStream(
                new FileInputStream(privateKeyFile));
        this.privateKey = (Key) keyIn.readObject();
        this.isDecryptInitialized = true;
        keyIn.close();
    }
 
    /**
     * Construct a new RSA encryptor in encrypt and decrypt mode with the
     * specified public and private key.
     * @param publicKey the public key (used to encrypt files and streams).
     * @param privateKey the private key (used to decrypt files and streams).
     **/
    public RSAEncryptor(PublicKey publicKey, PrivateKey privateKey)
    {
        this.publicKey = publicKey;
        this.isEncryptInitialized = true;
        this.privateKey = privateKey;
        this.isDecryptInitialized = true;
    }
 
    /**
     * Construct a new RSA encryptor in encrypt and decrypt mode with the
     * specified pair of keys.
     * @param keyPair the pair of keys used to encrypt and decrypt files and
     * streams.
     **/
    public RSAEncryptor(KeyPair keyPair)
    {
        this(keyPair.getPublic(), keyPair.getPrivate());
    }
 
    /**
     * Returns the public key of the underlying encryptor.
     * @return the public key of the underlying encryptor.
     **/
    public PublicKey getPublicKey()
    {
        return (PublicKey) publicKey;
    }
 
    /**
     * Sets the public key of the underlying encryptor.
     * @param key the public key to set.
     **/
    public void setPublicKey(PublicKey key)
    {
        this.publicKey = key;
    }
 
    /**
     * Returns the private key of the underlying encryptor.
     * @return the private key of the underlying encryptor.
     **/
    public PrivateKey getPrivateKey()
    {
        return (PrivateKey) privateKey;
    }
 
    /**
     * Returns a new instance of RSAEncryptor with the specified size for
     * generated keys.
     * @param size the size of the generated keys.
     * @return a new instance of RSAEncryptor.
     **/
    public static RSAEncryptor getInstance(int size)
    {
        return new RSAEncryptor(generateKeys(size));
    }
 
    /**
     * Returns a new instance of RSAEncryptor with the specified size for
     * generated keys and writes them into the specified files.
     * @return a new instance of RSAEncryptor.
     * @param size the size of the generated keys.
     * @param publicKeyFileName the name of the file in wich youw ant to write
     * the public key.
     * @param privateKeyFileName the name of the file in wich youw ant to write
     * the private key.
     * @throws java.io.IOException if an error occurs during writing one of the keys.
     */
    public static RSAEncryptor getInstance(int size, String publicKeyFileName,
            String privateKeyFileName) throws IOException
    {
        return new RSAEncryptor(generateAndSaveKeys(size, publicKeyFileName, privateKeyFileName));
    }
 
    /**
     * Returns a new instance of RSAEncryptor with the specified size for
     * generated keys and writes them into the specified files.
     * @return a new instance of RSAEncryptor.
     * @param size the size of the generated keys.
     * @param publicKeyFile the file in wich youw ant to write the public key.
     * @param privateKeyFile the file in wich youw ant to write the private key.
     * @throws java.io.IOException if an error occurs during writing one of the keys.
     */
    public static RSAEncryptor getInstance(int size, File publicKeyFile, 
            File privateKeyFile) throws IOException
    {
        return new RSAEncryptor(generateAndSaveKeys(size, publicKeyFile, privateKeyFile));
    }
 
    /**
     * Returns a pair of keys generated with the specified size.
     * @return a pair of keys generated with the specified size.
     * @param size the size of the generated key.
     */
    public static KeyPair generateKeys(int size)
    {
        KeyPairGenerator pairgen = null;
        try
        {
            pairgen = KeyPairGenerator.getInstance("RSA");
        } 
        catch (NoSuchAlgorithmException ex)//never launched
        {
            ex.printStackTrace();
        }
        SecureRandom random = new SecureRandom();
        pairgen.initialize(size, random);
        KeyPair keyPair = pairgen.generateKeyPair();
        return keyPair;
    }
 
    /**
     * Returns a pair of keys generated with the specified size and writes 
     * them into the specified files.
     * @param size the size of the generated keys.
     * @param publicKeyFileName the name of the file in wich youw ant to write
     * the public key.
     * @param privateKeyFileName the name of the file in wich youw ant to write
     * the private key.
     * @return a pair of keys with the specified size.
     * @throws java.io.IOException if an error occurs during writing the keys.
     **/
    public static KeyPair generateAndSaveKeys(int size, String publicKeyFileName, 
            String privateKeyFileName) throws IOException
    {
        return generateAndSaveKeys(size, new File(publicKeyFileName), new File(privateKeyFileName));
    }
 
    /**
     * Returns a pair of keys generated with the specified size and writes 
     * them into the specified files.
     * @param size the size of the generated keys.
     * @param publicKeyFile the file in wich you want to write the public key.
     * @param privateKeyFile the file in wich you want to write the private key.
     * @return a pair of keys with the specified size.
     * @throws java.io.IOException if an error occurs during writing the keys.
     **/
    public static KeyPair generateAndSaveKeys(int size, File publicKeyFile, 
            File privateKeyFile) throws IOException
    {
        KeyPair keyPair = generateKeys(size);
 
        ObjectOutputStream out = new ObjectOutputStream(
                new FileOutputStream(publicKeyFile));
        out.writeObject(keyPair.getPublic());
        out.close();
 
        out = new ObjectOutputStream(
                new FileOutputStream(privateKeyFile));
        out.writeObject(keyPair.getPrivate());
        out.close();
 
        return keyPair;
    }
 
    /**
     * Encrypts the specified input stream to the specified output stream.
     * 
     * @param in the stream to encrypt.
     * @param out the stream where you want to write the encrypted stream.
     * @throws java.io.IOException if an error occurs during writing encrypted
     * datas.
     * @throws java.security.InvalidKeyException if the key is not valid for
     * this type of operation.
     */
    public void encryptStream(InputStream in, OutputStream out) 
        throws InvalidKeyException, IOException
    {
        if(!this.isEncryptInitialized)
            throw new IllegalStateException("The underlying encryptor is not" +
                    " initialized in encrypt mode. You must specify a " +
                    "public key.");
        KeyGenerator keygen = null;
        Cipher cipherRsa = null;
        Cipher cipherAes= null;
        try
        {
            keygen = KeyGenerator.getInstance("AES");
            cipherRsa = Cipher.getInstance("RSA");
            cipherAes = Cipher.getInstance("AES");
        }
        catch(NoSuchAlgorithmException e)//never launched
        {
            e.printStackTrace();
        }
        catch(NoSuchPaddingException e)
        {
            e.printStackTrace();
        }
        SecureRandom random = new SecureRandom();
        keygen.init(random);
        SecretKey key = keygen.generateKey();
 
        cipherRsa.init(Cipher.WRAP_MODE, publicKey);
        byte[] wrappedKey = null;
        try
        {
            wrappedKey = cipherRsa.wrap(key);
        } 
        catch (InvalidKeyException ex)
        {
            ex.printStackTrace();
        } 
        catch (IllegalBlockSizeException ex)
        {
            ex.printStackTrace();
        }
 
        Integer length = wrappedKey.length;
        DataOutputStream writer = new DataOutputStream(out);
        writer.writeInt(length);
        writer.write(wrappedKey);
 
        cipherAes.init(Cipher.ENCRYPT_MODE, key);
        super.crypt(in, writer, cipherAes);
//        in.close();
//        out.close();
        //writer.close();
    }
 
    /**
     * Decrypts the specified input stream to the specified output stream.
     * @param in the stream to decrypt.
     * @param out the stream where you want to write the decrypted stream.
     * @throws java.io.IOException if an error occurs during writing encrypted
     * datas.
     * @throws java.security.InvalidKeyException if the key is not valid for
     * this type of operation.
     */
    public void decryptStream(InputStream in, OutputStream out) 
        throws IOException, InvalidKeyException
    {
        if(!this.isEncryptInitialized)
            throw new IllegalStateException("The underlying encryptor is not" +
                    " initialized in decrypt mode. You must specify a " +
                    "private key.");
        DataInputStream reader = new DataInputStream(in);
        int length = reader.readInt();
        byte[] wrappedKey = new byte[length];
        in.read(wrappedKey, 0, length);
        Cipher cipherRsa = null;
        Cipher cipherAes = null;
        Key key = null;
        try
        {
            cipherRsa = Cipher.getInstance("RSA");
            cipherAes = Cipher.getInstance("AES");
            cipherRsa.init(Cipher.UNWRAP_MODE, privateKey); 
            key = cipherRsa.unwrap(wrappedKey, "AES", Cipher.SECRET_KEY);
        }
        catch(NoSuchAlgorithmException e)//never thrown
        {
            e.printStackTrace();
        }
        catch(NoSuchPaddingException e)
        {
            e.printStackTrace();
        }
 
        cipherAes.init(Cipher.DECRYPT_MODE, key);
 
        super.crypt(reader, out, cipherAes);
//        in.close();
//        out.close();
        //reader.close();
    }
 
}

j'ai tout essayé pour décrypter et me récupère systématiquement:

The underlying encryptor is not initialized in decrypt mode. You must specify a private key.

Il y a une erreur dans mon code, mais elle crève les yeux ;-)
Code:

1 2 3 4 5 6 7 public void decryptStream(InputStream in, OutputStream out) throws IOException, InvalidKeyException { if(!this.isEncryptInitialized) //blabla }
A changer par :
Code:

1 2 3 4 5 6 7 public void decryptStream(InputStream in, OutputStream out) throws IOException, InvalidKeyException { if(!this.isDecryptInitialized) //blabla }
Les classes postées ici ne sont peut-être pas les dernières versions existantes. Mais tout au plus ellent souffrent de défauts bidons tels que celui-là. Erreurs de copier/coller en refactoring :s

Voici une source permettant de creer une "etched border" ayant le nombre de cotes que l'on veut.

(les constructeurs pour une border a plus d'un cote sont un peu rebarbatif, si quelqu'un a une meilleure idee je suis preneuse!)

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
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
231
232
233
234
235
236
237
238
239
 
 
/*
 * SidedEtchedBorder.java
 *
 * Created on 18-Mar-2010
 */
package my.util.ui.border;
 
import java.awt.Color;
import java.awt.Component;
import java.awt.Graphics;
import java.awt.Insets;
 
import javax.swing.SwingConstants;
import javax.swing.border.EtchedBorder;
 
/**
 * This class creates an etched border that can be one,
 * two, three or four sided. 
 * <p>
 * As his parent <code>javax.swing.border.EtchedBorder</code> {@link javax.swing.border.EtchedBorder}:
 * <ul>
 * <li> The border can be etched-in or etched-out.
 * <li> If colors highlight/shadow aren't initialized, they will be
 * derived from the component for which the border is being painted.
 * </ul>
 *
 * @author Julie Duvillier
 */
public class SidedEtchedBorder 
        extends EtchedBorder{
 
    /* Booleans holding which side of the border will be paint. */
    private boolean top, left,bottom,right;
 
    /**
     * Creates four sided a lowered etched border with default colors.
     */
    public SidedEtchedBorder(){
        this(LOWERED,true, true, true, true);
    }
 
    /**
     * Creates a sided lowered etched border with default colors.
     * @param top           if <code>true</code> the top side will be painted
     * @param left          if <code>true</code> the left side will be painted
     * @param bottom        if <code>true</code> the bottom side will be painted
     * @param right         if <code>true</code> the right side will be painted
     */
    public SidedEtchedBorder(boolean top, boolean left,boolean bottom, boolean right){
        this(LOWERED,null,null, top, left,bottom, right);
    }
 
    /**
     * Created a sided etched border with the specifed etch-type
     * and default colors.
     * @param etchType      the type of etch to be paint
     * @param top           if <code>true</code> the top side will be painted
     * @param left          if <code>true</code> the left side will be painted
     * @param bottom        if <code>true</code> the bottom side will be painted
     * @param right         if <code>true</code> the right side will be painted
     */
    public SidedEtchedBorder(int etchType,
                             boolean top, boolean left,boolean bottom, boolean right){
         this(etchType,null,null, top, left,bottom, right);
 
    }
 
    /**
     * Creates a sided lowered etched border with the specified colors.
     * @param highlight     the color to use for highlight
     * @param shadow        the color to use for shadow
     * @param top           if <code>true</code> the top side will be painted
     * @param left          if <code>true</code> the left side will be painted
     * @param bottom        if <code>true</code> the bottom side will be painted
     * @param right         if <code>true</code> the right side will be painted
     */
    public SidedEtchedBorder(Color highlight, Color shadow,
                             boolean top, boolean left,boolean bottom, boolean right){
 
    }
 
    /**
     * Creates a sided etched border with the specified etch-type.
     * and colors.
     * @param etchType      the type of etch to be paint
     * @param highlight     the color to use for highlight
     * @param shadow        the color to use for shadow
     * @param top           if <code>true</code> the top side will be painted
     * @param left          if <code>true</code> the left side will be painted
     * @param bottom        if <code>true</code> the bottom side will be painted
     * @param right         if <code>true</code> the right side will be painted
     */
     public SidedEtchedBorder(int etchType,
                              Color highlight, Color shadow,
              boolean top, boolean left,boolean bottom, boolean right){
        super(etchType, highlight, shadow);
        this.top = top;
        this.right = right;
        this.bottom = bottom;
        this.left = left;
 
     }
 
     /**
      * Creates a one sided lowered etched border with default colors.
      * @param side the side to be draw
      */
     public SidedEtchedBorder( int side){
         this(side,LOWERED,null,null);
     }
 
     /**
      * Creates a one sided lowered etched border with the specified etch-type
      * and default colors.
      * @param side         the side to be draw
      * @param etchType     the type of etch to be paint
      */
     public SidedEtchedBorder(int side,int etchType ){
         this(side,LOWERED,null,null);
     }
 
     /**
      * Creates a one sided lowered etched border with specifed colors.
      * @param side         the side to be draw
      * @param highlight    the color to use for highlight
      * @param shadow       the color to use for shadow
      */
     public SidedEtchedBorder(int side,Color highlight, Color shadow){
         this(side,LOWERED,highlight,shadow);
     }
     /**
      * Creates a one sided etched border with the specified etch-type
      * and colors.
      * @param side          the side to be draw
      * @param etchType      the type of etch to be paint
      * @param highlight     the color to use for highlight
      * @param shadow        the color to use for shadow
      */
     public SidedEtchedBorder( int side, int etchType, Color highlight, Color shadow){
        this(etchType,highlight,shadow, false,false,false,false);
        switch(side){
            case SwingConstants.TOP: top =true; break;
            case SwingConstants.LEFT: left =true; break;
            case SwingConstants.BOTTOM: bottom =true; break;
            case SwingConstants.RIGHT: right =true; break;
         }
     }
 
 
 
     /**
      * Paints the border for the specified component
      * with the specified position and size.
      */
    @Override
    public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
        g.translate(x, y);
        int w = width ;
        int h= height;
 
        Color col1 = (etchType == LOWERED)? getShadowColor(c)
                                          : getHighlightColor(c);
 
        Color col2 = (etchType == LOWERED)? getHighlightColor(c)
                                          : getShadowColor(c);
 
        if( top ){
            drawLine(g,col1,0, 0, w-2, 0);
            drawLine(g,col2,1, 1, w-3, 1);
        }
        if( left ){
            drawLine(g,col1,0, 0, 0, h-2);
            drawLine(g,col2,1, h-3, 1, 1);
        }
        if( bottom){
            drawLine(g,col1,0, h-2, w-2, h-2);
            drawLine(g,col2,0, h-1, w-1, h-1);
        }
        if( right){
            drawLine(g,col1, w-2, 0 , w-2, h-2);
            drawLine(g,col2,w-1, h-1, w-1, 0);
        }
 
        g.translate(-x, -y);
    }
 
    /**
     * Draw a line with the specifed graphics, color, between the points
     * of coordinates A1(x1,y1) and A2(x2,y2).
     * @param g         the graphics objects to use
     * @param color     the color of the line to be draw
     * @param x1        abscissa of A1
     * @param y1        ordinate of A1
     * @param x2        abscissa of A2
     * @param y2        ordinate of A2
     */
    private void drawLine(Graphics g,Color color, int x1, int y1, int x2, int y2 ){
        g.setColor(color);
        g.drawLine(x1, y1, x2, y2);
    }
 
    /**
     * Gets the insets of the border.
     * @param c         the component for which the border is painted
     * @return          the <code>Insets</code> object of the border
     */
    @Override
     public Insets getBorderInsets(Component c) {
        return getBorderInsets(c, new Insets(0, 0, 0, 0));
    }
 
    /**
     * Gets the insets of the border after reinitializing it
     * with border insets.
     * @param c         the component for which the border is painted
     * @param insets    the <code>Insets</code> object to be reinitialized
     * @return          the <code>Insets</code> object of the border
     */
    @Override
     public Insets getBorderInsets(Component c, Insets insets) {
        insets.left = insets.top = insets.right = insets.bottom = 0;
        if( top ){
            insets.top = 2;
        }
        if(left) {
            insets.left =2;
        }
        if(bottom){
            insets.bottom = 2;
        }
        if(right){
            insets.right =2;
        }
        return insets;
    }
 
}

Citation:

Envoyé par petibras

les constructeurs pour une border a plus d'un cote sont un peu rebarbatif, si quelqu'un a une meilleure idee je suis preneuse!

Une proposition :

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
public class SidedEtchedBorder extends EtchedBorder {
 
	public enum EnumSide {
		TOP, LEFT, BOTTOM, RIGHT;
	}
 
	private Collection<EnumSide> sides;
 
	public SidedEtchedBorder() {
		this(EnumSide.values());
	}
 
	public SidedEtchedBorder(EnumSide... sides) {
		this(LOWERED, sides);
	}
 
	public SidedEtchedBorder(int etchType) {
		this(etchType, EnumSide.values());
	}
 
	public SidedEtchedBorder(int etchType, EnumSide... sides) {
		this(etchType, null, null, sides);
	}
 
	public SidedEtchedBorder(Color highlight, Color shadow) {
		this(LOWERED, highlight, shadow);
	}
 
	public SidedEtchedBorder(int etchType, Color highlight, Color shadow) {
		this(etchType, highlight, shadow, EnumSide.values());
	}
 
	public SidedEtchedBorder(Color highlight, Color shadow, EnumSide... sides) {
		this(LOWERED, highlight, shadow, sides);
	}
 
	public SidedEtchedBorder(int etchType, Color highlight, Color shadow,
			EnumSide... sides) {
		super(etchType, highlight, shadow);
		this.sides = new HashSet<EnumSide>(Arrays.asList(sides));
	}
 
	@Override
	public void paintBorder(Component c, Graphics g, int x, int y, int width,
			int height) {
		// ...
 
		if (edging(EnumSide.TOP)) {
			// ...
		}
		if (edging(EnumSide.LEFT)) {
			// ...
		}
		if (edging(EnumSide.BOTTOM)) {
			// ...
		}
		if (edging(EnumSide.RIGHT)) {
			// ...
		}
 
		// ...
	}
 
	@Override
	public Insets getBorderInsets(Component c, Insets insets) {
		// ...
 
		if (edging(EnumSide.TOP)) {
			// ...
		}
		if (edging(EnumSide.LEFT)) {
			// ...
		}
		if (edging(EnumSide.BOTTOM)) {
			// ...
		}
		if (edging(EnumSide.RIGHT)) {
			// ...
		}
 
		return insets;
	}
 
	protected boolean edging(EnumSide side) {
		return this.sides.contains(side);
	}
}

09/05/2010, 18h27
Auteur

[JTabbedPane] setMnemonicAt et les chiffres

bonjour,

il y a quelques temps déjà je voulais avoir la possibilité d'utiliser les raccourcis Alt+1, Alt+2 sur un JTabbedPane pour passer d'un onglet à l'autre.

Voici donc ma contribution :
http://www.developpez.net/forums/d78...icat-chiffres/

1 pièce(s) jointe(s)

[Java/Swing] PopupEditor pour un JTable

Bonsoir,
il s'agit d'une classe permettant d'éditer une cellule de JTable sous la forme d'un PopupMenu.
Le PopupMenu contient des checkBoxMenuItem permettant de sélectionner plusieurs éléments en même temps, et présélectionnés selon la valeur de la cellule.

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
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
package popup;
 
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.List;
 
import javax.swing.AbstractCellEditor;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JTable;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableCellRenderer;
 
public class PopupEditor extends AbstractCellEditor implements TableCellEditor,
        PropertyChangeListener {
 
    private TableCellRenderer renderer;
 
    private JXPopupMenu popupMenu = new JXPopupMenu();
 
    private JButton validate = makeButton("\u21B5", Color.GREEN.darker(),
            new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    stopCellEditing();
                }
            });
 
    private JButton cancel = makeButton("X", Color.RED, new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            cancelCellEditing();
        }
    });
 
    private JPanel panelButtons;
 
    protected JXCheckBoxMenuItem[] checkBoxMenuItems;
 
    private static final MouseListener mouseListener = new MouseAdapter() {
    };
 
    public PopupEditor(TableCellRenderer renderer, Object[] items) {
        this.renderer = renderer;
 
        panelButtons = new JPanel(new FlowLayout(FlowLayout.RIGHT, 0, 0));
        panelButtons.add(validate);
        panelButtons.add(cancel);
 
        setChoosableItems(items);
    }
 
    protected JButton makeButton(String text, Color color,
            ActionListener listener) {
        JButton button = new JButton(text);
        button.setForeground(color);
        button.setBorder(BorderFactory.createRaisedBevelBorder());
        button.setFocusPainted(false);
        button.addActionListener(listener);
        return button;
    }
 
    public boolean stopCellEditing() {
        popupMenu.close();
        return super.stopCellEditing();
    }
 
    public void cancelCellEditing() {
        popupMenu.close();
        super.cancelCellEditing();
    }
 
    public void setChoosableItems(Object[] items) {
        popupMenu.removeAll();
 
        this.checkBoxMenuItems = new JXCheckBoxMenuItem[items.length];
        for (int i = 0; i < items.length; i++) {
            JXCheckBoxMenuItem menuItem = new JXCheckBoxMenuItem(items[i]);
            checkBoxMenuItems[i] = menuItem;
            popupMenu.add(menuItem);
        }
 
        popupMenu.addSeparator();
        popupMenu.add(panelButtons);
        popupMenu.pack();
        popupMenu.setPackSize(popupMenu.getPreferredSize());
    }
 
    public Object getCellEditorValue() {
        List l = new ArrayList();
        for (int i = 0; i < checkBoxMenuItems.length; i++) {
            JXCheckBoxMenuItem menuItem = checkBoxMenuItems[i];
            if (menuItem.isSelected()) {
                l.add(menuItem.getItem());
            }
        }
        return l.toArray();
    }
 
    protected void setCellEditorValue(Object value) {
        for (int i = 0; i < checkBoxMenuItems.length; i++) {
            JXCheckBoxMenuItem menuItem = checkBoxMenuItems[i];
            menuItem.setSelected(false);
        }
 
        if (value != null) {
            Object[] v = (Object[]) value;
            for (int i = 0; i < checkBoxMenuItems.length; i++) {
                JXCheckBoxMenuItem menuItem = checkBoxMenuItems[i];
                for (int j = 0; j < v.length; j++) {
                    if (v[j] != null && menuItem.getItem().equals(v[j])) {
                        menuItem.setSelected(true);
                        break;
                    }
                }
            }
        }
    }
 
    public void propertyChange(PropertyChangeEvent evt) {
        if (evt.getOldValue() == this && evt.getNewValue() == null) {
            popupMenu.close();
        }
    }
 
    public Component getTableCellEditorComponent(JTable table, Object value,
            boolean isSelected, int row, int column) {
        table.removePropertyChangeListener("tableCellEditor", this);
        table.addPropertyChangeListener("tableCellEditor", this);
 
        setCellEditorValue(value);
 
        Rectangle rect = table.getCellRect(row, column, false);
        Dimension size = popupMenu.getPackSize();
        popupMenu.setPreferredSize(new Dimension(Math.max(rect.width,
                size.width), size.height));
        popupMenu.show(table, rect.x, rect.y + rect.height);
 
        Component comp = renderer.getTableCellRendererComponent(table, value,
                isSelected, false, row, column);
        comp.removeMouseListener(mouseListener);
        comp.addMouseListener(mouseListener);
        return comp;
    }
 
    private static class JXPopupMenu extends JPopupMenu {
 
        private Dimension packSize;
 
        private boolean closeable;
 
        public Dimension getPackSize() {
            return packSize;
        }
 
        public void setPackSize(Dimension packSize) {
            this.packSize = packSize;
        }
 
        public void close() {
            closeable = true;
            setVisible(false);
        }
 
        public void setVisible(boolean b) {
            if (b || closeable) {
                super.setVisible(b);
                closeable = false;
            }
        }
    }
 
    private static class JXCheckBoxMenuItem extends JCheckBoxMenuItem {
 
        private Object item;
 
        public JXCheckBoxMenuItem(Object item) {
            super(item.toString());
            this.item = item;
        }
 
        public Object getItem() {
            return item;
        }
    }
 
}

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
package popup;
 
import javax.swing.table.DefaultTableCellRenderer;
 
public class ArrayTableCellRenderer extends DefaultTableCellRenderer {
 
    private String separator;
 
    public ArrayTableCellRenderer() {
        this(null);
    }
 
    public ArrayTableCellRenderer(String separator) {
        this.separator = separator != null ? separator : " ";
    }
 
    protected void setValue(Object value) {
        if (value != null) {
            value = format((Object[]) value);
        }
        super.setValue(value);
    }
 
    protected Object format(Object[] values) {
        boolean separate = false;
        StringBuffer sb = new StringBuffer();
 
        for (int i = 0; i < values.length; i++) {
            if (values[i] != null) {
                if (separate) {
                    sb.append(getSeparator());
                }
                sb.append(values[i]);
                separate = true;
            }
        }
        return sb;
    }
 
    protected String getSeparator() {
        return separator;
    }
 
    protected void setSeparator(String separator) {
        this.separator = separator;
    }
}

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 popup;
 
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.TableCellRenderer;
 
public class TestPopupEditor extends JFrame {
 
    public TestPopupEditor() {
        Object[] couleurs = { "Blanc", "Rouge", "Vert", "Bleu", "Jaune", "Noir" };
        Object[] formes = { "Rond", "Carré", "Triangle" };
        Object[] poids = { "1kg", "2kg", "3kg", "4kg", "5kg" };
 
        JTable jTable = new JTable(new Object[][] {
                new Object[] { new Object[] { "Rouge", "Vert" }, null, null },
                new Object[] { null, new Object[] { "Carré", "Triangle" },
                        new Object[] { "1kg", "2kg" } }, new Object[3] },
                new String[] { "Couleurs", "Formes", "Poids" });
 
        jTable.setDefaultRenderer(Object.class, new ArrayTableCellRenderer());
 
        TableCellRenderer popupRenderer = new ArrayTableCellRenderer();
        jTable.getColumnModel().getColumn(0).setCellEditor(
                new PopupEditor(popupRenderer, couleurs));
        jTable.getColumnModel().getColumn(1).setCellEditor(
                new PopupEditor(popupRenderer, formes));
        jTable.getColumnModel().getColumn(2).setCellEditor(
                new PopupEditor(popupRenderer, poids));
 
        getContentPane().add(new JScrollPane(jTable));
        setSize(600, 300);
        setVisible(true);
    }
 
    public static void main(String[] args) {
        new TestPopupEditor();
    }
}

09/05/2010, 22h31
herve91

2 pièce(s) jointe(s)

[Java/Swing] Librairie Java Drag & Drop
Bonsoir,

il s'agit d'une librairie permettant de faire du drag&drop dans une application Java/Swing au sein d'une fenêtre JFrame, JDialog ou JWindow, via le glasspane de la fenêtre.

Le drag s'applique sur des composants Swing et s'accompagne d'effets visuels comme la superposition d'une image translucide sur l'objet à déplacer, et ce jusqu'au drop sur l'objet cible. L'objet cible dispose également d'un effet visuel paramétrable dynamiquement (surbrillance, bordure, forme pleine, etc.).

La sélection du drag peut être multiple par simple clique sur chacun des objets à déplacer, puis glissement du dernier objet sélectionné vers la cible. Sur chaque objet sélectionné, l'image translucide clignote tant que le glissement n'est pas réalisé. En cliquant de nouveau sur un objet sélectionné, l'image disparaît.

Il est possible de définir le niveau de transparence de l'image pour chaque objet source, ainsi que l'image elle-même :
1. picture : fichier image en ressource de l'application
2. component : il s'agit d'une image du composant calculée en mémoire
3. text : un texte mono ou multi lignes affiché à la façon d'une info-bulle, avec la possibilité de définir la couleur de fond de la vignette ainsi que l'alignement du texte à l'intérieur (gauche, centré, droite).
Toutes les classes sont extensibles permettant d'ajouter facilement d'autres comportements.
Il est également possible de définir des groupes d'objets autorisés à être déplacés ensemble. Enfin, un système de notification est mis en place pour déclencher des traitements clients à l'issue du drop.
Le fichier joint contient les classes compilées, les sources, ainsi qu'une démonstration des possibilités de la librairie. Il porte l'extension .zip. Une fois le téléchargement effectué, il faut renommer l'extension .zip en .jar pour obtenir le fichier "dnd.jar"

1 pièce(s) jointe(s)

Boîte de dialogue permettant de proposer un choix de fonte

Auteur : commence par 'M' et finit par 'I', en trois lettres ...
Voilà après avoir passé de longues heures (bon d'accord, au moins 1) sur le Net parmi des solutions qui ne me plaisaient pas, j'ai décidé de coder moi-même une boîte de dialogue qui propose à l'utilisateur de choisir une fonte de caractères (police, style et taille) parmi celles installées sur son système.

L'apparence est plutôt 'classique' (voir image jointe).

Il faut spécifier la fonte par défaut à la création de la boîte de dialogue.

Seul le champ de texte affichant la taille est éditable, pour les autres on peut seulement choisir parmi les valeurs des listes correspondantes.

D'autre part, l'ensemble n'est pas inséré directement dans le conteneur de la boîte de dialogue, mais dans un panneau, ce qui facilite la mise en place d'un système d'onglets lorsque l'on veut proposer d'autres options (choix de taille, de couleur, etc.)

J'ai essayé de commenter tant que possible :aie:

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
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
/*
 * Développé par ZeusOlym
 * Contact : <lev.grec@gmail.com>
 * Merci de donner un objet à votre mail
 * 
 */
 
import java.awt.* ;
import java.awt.event.* ;
import javax.swing.* ;
import javax.swing.event.* ;
 
/*===================Classe permettant de proposer un choix de police de caractères===================
 * 
 * Créer la boîte :
 * 
 * ChoixDePolice choix = new ChoixDePolice(Font police_de_départ);
 * Un objet dérivé de JDialog est créé
 * 
 * Pour récupérer la valeur entrée par l'utilisateur :
 * fontGetter() : Font
 * 
 * Pour détruire la boîte (par défaut, elle est seulement masquée à sa fermeture) :
 * dispose() : void
 * 
 *====================================================================================================*/
 
//Création de la boîte de dialogue
@SuppressWarnings("serial")
class ChoixDePolice extends JDialog{
	public ChoixDePolice(final Font f){
		//Créer la boîte
		super((JFrame)null, "Choix de la fonte", true);
		//Créer le panneau
		polices = new Polices(f, this);
		scroll_police = new JScrollPane(polices);
		add(scroll_police);
		polices.setter(f);
		//Modifier le comportement pour que la fermeture de la boîte aie le même résultat
		//qu'un clic sur 'Annuler'
		addWindowListener(new WindowAdapter(){
			public void windowClosing(WindowEvent e){
				polices.setter(f);
			}
		});
		//Dimensionner et afficher la boîte
		pack();
		setLocationRelativeTo(null);
		setVisible(true);
	}
 
	//Récupérer la fonte demandée
	public Font fontGetter(){
		return polices.getter();
	}
	Dimension dims; JScrollPane scroll_police; static Polices polices;
 
 
	//Création du panneau gérant la police
	class Polices extends JPanel implements ActionListener{
		public Polices(Font f, JDialog appel){
			//Permet d'utiliser f et appel en dehors du constructeur
			arg0 = f;
			arg1 = appel;
 
			//Création du champ exemple et de tableaux contenant le choix proposé
			exemple = new JTextField("Voix ambiguë d'un coeur qui, au zéphyr, préfère les jattes de kiwis", 24);
			exemple.setEditable(false);
 
			tailles = new String[]{"6","8","10","11","12","14","16","18","20","22","24","26","28","30","32","34","36","40","44","48"};
			styles = new String[]{"Normal", "Gras", "Italique", "Gras et Italique"};
			polices = GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames();
 
			//Création des box JTextField + JList permettant de choisir
			fonte = new Vertical(0, polices, false);
			style = new Vertical(0, styles, false);
			size = new Vertical(0, tailles, true);
 
			//Création des boutons de fin de dialogue
			annuler = new JButton("Annuler");
			annuler.addActionListener(this);
			ok = new JButton("OK");
			ok.addActionListener(this);
 
			//Box contenant les boutons
			prov_valid = Box.createHorizontalBox();
			prov_valid.add(annuler);
			prov_valid.add(Box.createHorizontalStrut(5));
			prov_valid.add(ok);
 
			entier = Box.createVerticalBox();
 
			//Box gérant la mise en page des boutons
			valid = Box.createHorizontalBox();
			valid.add(Box.createGlue());
			valid.add(prov_valid);
 
			//Box gérant la mise en page des listes de choix
			settings = Box.createHorizontalBox();
			settings.add(fonte);
			settings.add(Box.createHorizontalStrut(5));
			settings.add(style);
			settings.add(Box.createHorizontalStrut(5));
			settings.add(size);
 
			//Box contenant l'intégralité des composants
			entier.add(settings);
			entier.add(Box.createVerticalStrut(5));
			entier.add(exemple);
			entier.add(Box.createVerticalStrut(5));
			entier.add(valid);
 
			//Remplissage des valeurs par défauts et affichage de l'exemple
			setter(f);
			exemple();
 
			//Écouter le champ de texte de saisie de la taille afin que les modifications
			//soient répercutées lorsque son contenu change
			size.resultat.addActionListener(this);
 
			//Ajout du résultat au panneau
			add(entier);
		}
 
		//Remplir les JTextField de résultat avec les valeurs par défaut transmises
		//sous forme d'objet 'Font'
		public void setter(Font f){
			fonte.resultat.setText(f.getName());
			size.resultat.setText(String.valueOf(f.getSize()));
			int prov = f.getStyle();
			String prov2 = "";
			if(prov==Font.PLAIN){prov2 = "Normal";}
			else if(prov==Font.BOLD){prov2 = "Gras";}
			else if(prov==Font.ITALIC){prov2 = "Italique";}
			else if(prov==Font.BOLD+Font.ITALIC){prov2 = "Gras et Italique";}
			style.resultat.setText(prov2);
		}
 
		//Retourner les valeurs saisies par l'utilisateur sous forme d'objet 'Font'
		public Font getter(){
			String prov = style.resultat.getText();
			if(prov.equals("Normal")){
				styl = Font.PLAIN;
			}
			else if(prov.equals("Gras")){
				styl = Font.BOLD;
			}
			else if(prov.equals("Italique")){
				styl = Font.ITALIC;
			}
			else if(prov.equals("Gras et Italique")){
				styl = Font.BOLD+Font.ITALIC;
			}
			if(size.resultat.getText().equals("")==false){
				font = new Font(fonte.resultat.getText(), styl, Integer.parseInt(size.resultat.getText()));
				return font;
			}
			else{
				JOptionPane.showMessageDialog(null, "Vous n'avez pas spécifié de taille !", "Erreur de saisIe", JOptionPane.ERROR_MESSAGE);
				return null;
			}
		}
 
		//Afficher un exemple pour les valeurs sélectionnées
		public void exemple(){
			Font prov_font = getter();
			if(prov_font != null){
				exemple.setFont(prov_font);
			}
			else{System.out.println("Erreur : Impossible d'afficher l'exemple, l'appel de getter() a retourné une valeur nulle");}
		}
 
		//Gestion des évènements Action
		public void actionPerformed(ActionEvent e){
			if(e.getSource()==ok){
				//Faire disparaître la boîte de dialogue sans la détruire
				//pour pouvoir continuer à utiliser getter() de l'extérieur
				arg1.setVisible(false);
			}
			else if(e.getSource()==annuler){
				//Remettre les valeurs de départ puis
				//faire disparaître la boîte de dialogue sans la détruire
				//pour pouvoir continuer à utiliser getter() de l'extérieur
				setter(arg0);
				arg1.setVisible(false);
			}
			else if(e.getSource()==size.resultat){
				exemple();
			}
		}
 
		String [] tailles, polices, styles; Box settings, entier, valid, prov_valid; Vertical fonte, style, size;
		Font font; int styl; JTextField exemple; JButton ok, annuler; Font arg0; JDialog arg1;
	}
}
 
//Type créant un ensemble JTextField + JList servant au choix
@SuppressWarnings("serial")
class Vertical extends Box implements ListSelectionListener{
	//Créer un Box vertical contenant le champ de texte et la liste
	public Vertical(int i, String[] contenu, boolean edition){
		super(1);
		resultat = new JTextField();
		resultat.setEditable(edition);
		choix = new JList(contenu);
		choix.setSelectionMode(0);
		choix.setVisibleRowCount(10);
		choix.addListSelectionListener(this);
		defil = new JScrollPane(choix);
 
		//Ajouter les composants au Box
		add(resultat);
		add(Box.createVerticalStrut(3));
		add(defil);
	}
 
	//Remplir le champ de texte avec la valeur sélectionnée dans la liste
	public void valueChanged(ListSelectionEvent e){
		if(!e.getValueIsAdjusting()){
			resultat.setText((String)choix.getSelectedValue());
			ChoixDePolice.polices.exemple();
		}
	}
	JTextField resultat; JList choix; JScrollPane defil;
}

Toutes vos remarques et suggestions sont les bienvenues :ccool: !

Un synthétiseur facile à intégrer

Bonjour !

voici un synthétiseur MIDI facile à utiliser et à intégrer.
Il peut servir par exemple à faire des menus musicaux, comme dans AnAcondA.

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
 
import java.util.*;
import javax.sound.midi.*;
 
/* Un synthétiseur facile à utiliser
 *
 * 2011 Sylvain Tournois - http://sylv.tournois.free.fr/
 */
 
public class Synthe {
 
  public static void main(String[] args) {
    Synthe synth = new Synthe(); // construction et initialisation du synthétiseur (16 canaux)
    synth.program(0, "Crystal"); // programmation du canal 0 avec l'instrument "Crystal"
    synth.play(0, 60, 127); // jouer le DO du milieu
 
    System.out.println("Liste des instrumets disponibles :");
    String[] instrus = synth.getInstrumentsList(); // afficahge de la liste des instruments disponibles
    for (int i = 0 ; i < instrus.length ; i++) // pour chaque instrument
      System.out.println(instrus[i]); // écrire son nom
 
    synth.play(0, 62, 127); // jouer le RE du milieu (2 demis-tons au-dessus du DO)
 
    // affichage d'un message d'attente de clavier
    System.out.println("\n2011 Sylvain Tournois - www.anadoncamille.com\n\nAppuyez sur la touche Entree pour terminer...");
    try {
      while (System.in.available() == 0); // tant que la touche Entrée n'est pas pressée, attendre
    }
    catch (Exception e) {
    }
 
    synth.close(); // cloture du synthétiseur
  }
 
  private Synthesizer synthesizer; // le synthétiseur
  private String[] instrumentsList; // liste des noms d'instruments disponibles
  private MidiChannel[] channels; // liste des canaux du synthétiseur (16, habituellement)
  private Hashtable instruments; // table de correspondance entre les noms d'instruments et leurs données
 
  // Construction et initialisation du synthétiseur
  public Synthe() {
    try {
      synthesizer = MidiSystem.getSynthesizer(); // récupération du synthétiseur standard
      synthesizer.open(); // ouverture du synthétiseur (obligatoire avant toute opération)
      synthesizer.loadAllInstruments(synthesizer.getDefaultSoundbank()); // chargement de la banque d'instruments par défaut
//      synthesizer.loadAllInstruments(getSoundbank(new File("maBanque.gm"))); // chargement d'une banque d'instruments spécifique
      Instrument[] is = synthesizer.getLoadedInstruments(); // récupération de la liste des instruments disponibles
      instruments = new Hashtable(); // préparation de la table de correspondance "nom <-> instrument"
      instrumentsList = new String[is.length]; // préparation de la liste des noms d'instruments disponibles
      for (int i = 0 ; i < is.length ; i++) { // pour chaque instrument de la liste
        instrumentsList[i] = is[i].getName(); // récupération du nom de l'instrument
        instruments.put(instrumentsList[i], is[i]); // création de la correspondance "nom <-> instrument"
      }
      channels = synthesizer.getChannels(); // récupération de la liste des canaux disponibles
    }
    catch (Exception e) { // gestion des excpetion
      e.printStackTrace(); // écriture de la trace d'exception
      synthesizer = null; // annulation du fonctionnement correct du synthétiseur
    }
  }
 
  // programmer l'instrument in sur le canal ch
  public void program(int ch, String in) {
    if (synthesizer == null) // si le synthétiseur n'a pas été correctement initialisé
      return; // court-circuiter la commande
    Instrument is = (Instrument)instruments.get(in); // recherche de l'inctrument correspondant au nom indiqué
    if (is == null) // si l'instrument est inconnu
      return; // court-circuiter la commande
    Patch p = is.getPatch(); // récupération des paramètres de l'instrument
    channels[ch].programChange(p.getBank(), p.getProgram()); // programmation du canal avec les paramètres de l'instrument
  }
 
  // jouer la note nt[0..127] avec la vélocité ve[0..127] sur le canal ch
  public void play(int ch, int nt, int ve) {
    if (synthesizer == null) // si le synthétiseur n'a pas été correctement initialisé
      return; // court-circuiter la commande
    channels[ch].noteOn(nt, ve); // jouer la note nt avec la vélocité ve sur le canal ch
  }
 
  public void close() {
    if (synthesizer == null) // si le synthétiseur n'a pas été correctement initialisé
      return; // court-circuiter la commande
    synthesizer.close(); // fermeture du synthétiseur
  }
 
  public String[] getInstrumentsList() {
    return instrumentsList;
  }
 
}

26/06/2011, 17h34
mlny84

Bonjour,

Une nouvelle application vous permettant de mettre en ligne vos sources directement à été mise en place.
Ce sujet est donc fermé et n'acceptera plus de nouveaux messages.

Je vous invite donc à mettre vos sources ici.

Merci à tous pour vos contributions.

Voir 40 message(s) de cette discussion en une page