[JFormattedTextField]Format spécial

Version imprimable

20/04/2004, 12h07
eraim

[JFormattedTextField]Format spécial

Bonjour,

J'ai regardé les messages déjà postés mais j'ai pas trouvé de solution à mon cas un peu spécial...
Je veux implémenter un JFormattedTextField qui permet à l'utilisateur d'entrer deux nombres séparés par un virgule. Mais je ne connais pas la taille de ces nombres, donc je ne sais pas combien de # écrire dans mon MaskFormatter...

Quelqu'un connaît-il une solution ?
20/04/2004, 17h00
narmataru

tu peux utilise un JTextField normal en lui associant un objet héritant de plainDocument redéfinissant la méthode insertString(int offs, String str, AttributeSet a) et dedans tu vérifie le format du texte avec une expression régulière "([0-9])+(,[0-9]+)?"...
21/04/2004, 08h43
eraim

Est-ce que tu n'aurai pas un exemple car je ne m'en sors pas trop...

Aller c'est mon jour de bonté, je te le sert sur un plateau :D

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
import java.util.regex.*;
import javax.swing.*;
import javax.swing.text.*;
 
public class TstPlainDocu extends JFrame{
 
	public JTextField jtf;
 
	public TstPlainDocu(){
		super("Test PlainDocu");
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		jtf = new JTextField(20);
		jtf.setDocument(new MyDocument());
 
		this.getContentPane().add(jtf);
 
		this.pack();
		this.show();
	}
 
	public static void main(String args[]){
		new TstPlainDocu();
	}
 
	protected class MyDocument extends PlainDocument{
		private String format = "^([0-9]+(,[0-9]*)?)?$";
		private Pattern regFloat; 
 
		public MyDocument(){
			super();
			this.regFloat = Pattern.compile(this.format);
		}
 
		public void insertString(int offset, String text, AttributeSet a) throws BadLocationException{
			String olds = this.getText(0, this.getLength());
			System.out.println("old : "+olds);
			super.insertString(offset, text, a);
			String news = this.getText(0, this.getLength());
			System.out.println("new : "+news);
 
			Matcher m = regFloat.matcher(news);
			if(!m.find()){
				System.out.println("PAS trouvé !");
				this.remove(0, this.getLength());
				this.insertString(0, olds, a);
			}
			else{
				System.out.println("trouvé !!");
			}
		}
 
	}
}

bonne journée :)

21/04/2004, 10h29
narmataru

Je l'ai mis dans la FAC (un peu modifié) s'il y en a que ça interresse :
http://www.developpez.net/forums/vie...=990240#990240
21/04/2004, 10h37
eraim

Merci, c'est presque cela... Il manque juste deux choses...

La virgule doit être obligatoire, et lorsque l'utilisateur commence à rentrer du texte, je veux qu'il sache qu'il doit rentrer un nombre, une virgule et un nombre...

Comment dois-je faire ?

Bon je dois être vraiment de bonne humeure :D

Donc pour que la ',' soit obligatoire j'ai changé le format par défaut. Et pour être sure qu'on ne l'efface pas j'ai surchargé la méthode remove et test s'il y a des caractère ineffaçable dans la zone à supprimer. Les caractère innéfaçable sont déclarés grace à la méthode .setUnRemovableChar(char[]) qui prend donc un tableau de caractère. puis pour montrer le format à l'utilisateur, je fais un setText 0,0 qui lui montre que l'on veut un chiffre à virgule et de plus insert la ',' qui ne pourra plus être effacée :)

voilou...

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
public class TstPlainDocu extends JFrame{
 
	public JTextField jtf;
 
	public TstPlainDocu(){
		super("Test PlainDocu");
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		jtf = new JTextField(20);
		MyDocument md = new MyDocument();
		md.setUnRemovableChar(new char[]{','});
		jtf.setDocument(md);
		jtf.setText("0,0");
		//jtf.setDocument(new MyDocument("^([aety]+(/[u]*)?)?$"));
		//jtf.setDocument(new MyDocument(MyDocument.MY_TYPE));
 
		this.getContentPane().add(jtf);
 
		this.pack();
		this.show();
	}
 
	public static void main(String args[]){
		new TstPlainDocu();
	}
 
	protected class MyDocument extends PlainDocument{
 
		public final static int INT_TYPE = 0;
		public final static int FLOAT_TYPE = 1;
		public final static int MY_TYPE = 2;
		public final static String FINT_TYPE = "^[0-9]*$";
		public final static String FFLOAT_TYPE = "^([0-9]+(,[0-9]*)?)?$";
		public final static String FMY_TYPE = "^([abcde]{0,5}(-[fghij]{0,3}(-[klmn]{0,6})?)?)?$";
		public final static String FDEFAULT = "^.*$";
 
		private char[] cantRemoveChar = new char[0];
		private String format = "^([0-9]+,([0-9]*)?)$"; // <- La virgule est devenue obligatoire
		private Pattern regFloat; 
 
		public MyDocument(){
			super();
			this.regFloat = Pattern.compile(this.format);
		}
 
		public MyDocument(String format){
			super();
			this.format = format;
			this.regFloat = Pattern.compile(this.format);
		}
 
		public MyDocument(int type){
			super();
			switch(type){
				case INT_TYPE:
					this.format = FINT_TYPE;
					break;
				case FLOAT_TYPE:
					this.format = FFLOAT_TYPE;
					break;
				case MY_TYPE:
					this.format = FMY_TYPE;
					break;
				default:
					this.format = FDEFAULT;
			}
			this.regFloat = Pattern.compile(this.format);
		}
 
		/** 
                 * Cette méthode initialise le document avec une chaine de caractères et défini un jeux de caractère que l'on ne peut pas supprimer.
                 */
		public void setUnRemovableChar(char[] cantRemoveChar){
			this.cantRemoveChar = cantRemoveChar;
		}
 
		/**
                 * On enregistre le texte courant, on effectue le insertString, puis on récupère le nouveau texte et on vérifie qu'il correspond au Pattern.
                 * S'il ne corespond pas on efface le texte et on remet l'ancien.
                 */
		public void insertString(int offset, String text, AttributeSet a) throws BadLocationException{
			String olds = this.getText(0, this.getLength());
			super.insertString(offset, text, a);
			String news = this.getText(0, this.getLength());
 
			Matcher mnew = regFloat.matcher(news);
			if(!mnew.find()){
				// Si le nouveau texte ne correspond pas au Pattern
				// je vide le JTextField (enfin le document), et je
				// remet l'ancien texte.
				super.remove(0, this.getLength());
				super.insertString(0, olds, a);
			}
		}
 
		/**
                 * On vérifie que l'on essaye pas d'effacer un carqctère inéfaçable.
                 * @see setUnRemovableChar()
                 */
		public void remove(int offs, int len) throws BadLocationException{
			boolean remove = true;
 
			if(offs < 0){
				super.remove(offs, len);
				return;
			}
 
			for(int i=0; i<cantRemoveChar.length && remove; i++){
				if(this.getText(0,getLength()).substring(offs, offs+len).indexOf(cantRemoveChar[i]) >= 0){
					remove = false;
				}
			}
 
			if(remove){
				super.remove(offs, len);
			}
		}
 
	}
}

21/04/2004, 11h58
eraim

Purée, tu es trop fort narmataru !!!
Merci à toi! :wink:
21/04/2004, 12h04
narmataru

de rien 8)

c'est dans la fac...
21/04/2004, 15h29
eraim

Une dernière question... :oops:

Peut-on vérifier le format à la perte du focus ?
21/04/2004, 16h52
narmataru

c'est à dire ? Le format est censé toujours être bon (c'est vrai que dans ce que je t'ai donné la chaine "," est valide :oops: ...)
21/04/2004, 16h57
eraim

Justement... Je veux que si finalement l'utilisateur ne veut rien mettre dans ce TextField, il le puisse et donc qu'il ne laisse pas la chaine ","...
22/04/2004, 10h09
eraim

C'est bon, j'ai résolu mon problème...

En fait, j'avais oublié qqch... :oops:

Vu que mon TextField est dans une JTable, je peux utiliser un CellEditor et sa méthode "editingStopped". Et c'est à la fin de l'édition que je vérifie le texte entré avec le format désiré...

Mais merci quand même! Cela m'a appris plein de choses sur les formats et la vérification à la volée! :wink:

bon ben ça c'est rien que pour toi car le code devient un peu laid (je te conseil de le rendre un peu plus claire, plus commenter, et de meilleur qualité....).
En gros ce que j'ai rajouté : un attribut qui dit si oui ou non le model accpete le champs vide. Si oui et que l'on a effecé tous les caractères, et qu'il ne reste que les non-effaçables, ils s'effacent automatiquement et le champs devient vide.
Si on essaye de rentrer à noiuveau un caractère on remet d'abord tous les caractères inéfaçable qu'il y avait avande la remize à 0 du texte.

Bon c'est claire qu'il y a des améliorations à faire mais l'idée est là :roll:

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
import java.util.regex.*;
import javax.swing.*;
import javax.swing.text.*;
import javax.swing.event.*;
 
public class TstPlainDocu extends JFrame{
 
	public JTextField jtf;
 
	public TstPlainDocu(){
		super("Test PlainDocu");
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		jtf = new JTextField(20);
		//MyDocument md = new MyDocument(MyDocument.MY_TYPE);
		MyDocument md = new MyDocument();
		//md.setUnRemovableChar(new char[]{'-'});
		md.setUnRemovableChar(new char[]{','});
		md.setCanBeEmpty(true);
		jtf.setDocument(md);
		//jtf.setText("a-f-k");
		jtf.setText("0,0");
		//jtf.setDocument(new MyDocument("^([aety]+(/[u]*)?)?$"));
		//jtf.setDocument(new MyDocument(MyDocument.MY_TYPE));
 
		this.getContentPane().add(jtf);
 
		this.pack();
		this.show();
	}
 
	public static void main(String args[]){
		new TstPlainDocu();
	}
 
	protected class MyDocument extends PlainDocument{
 
		public final static int INT_TYPE = 0;
		public final static int FLOAT_TYPE = 1;
		public final static int MY_TYPE = 2;
		public final static String FINT_TYPE = "^[0-9]*$";
		public final static String FFLOAT_TYPE = "^([0-9]+(,[0-9]*)?)?$";
		public final static String FMY_TYPE = "^([abcde]{0,5}(-[fghij]{0,3}(-[klmn]{0,6})?)?)?$";
		public final static String FDEFAULT = "^.*$";
 
		private char[] cantRemoveChar = new char[0];
 
		private String format = "^([0-9]+,([0-9]*)?)$";
		private Pattern regFloat;
 
		private boolean canBeEmpty = false;
		private String canBeEmptyFormat = "";
		private Pattern canBeEmptyPattern = null;
		private String saveStringBeforeEmpty = null;
 
		public MyDocument(){
			super();
			this.regFloat = Pattern.compile(this.format);
		}
 
		public MyDocument(String format){
			super();
			this.format = format;
			this.regFloat = Pattern.compile(this.format);
		}
 
		public MyDocument(int type){
			super();
			//assert type >= 0 : "Le nouveau type de MonPlain document est < 0";
			switch(type){
				case INT_TYPE:
					this.format = FINT_TYPE;
					break;
				case FLOAT_TYPE:
					this.format = FFLOAT_TYPE;
					break;
				case MY_TYPE:
					this.format = FMY_TYPE;
					break;
				default:
					this.format = FDEFAULT;
			}
			this.regFloat = Pattern.compile(this.format);
		}
 
		/** 
                 * Cette méthode initialise le document avec une chaine de caractères et défini un jeux de caractère que l'on ne peut pas supprimer.
                 */
		public void setUnRemovableChar(char[] cantRemoveChar){
			if(cantRemoveChar == null){
				return;
			}
 
			this.cantRemoveChar = cantRemoveChar;
 
			canBeEmptyFormat = "^[";
			for(int i=0; i<this.cantRemoveChar.length; i++){
				canBeEmptyFormat += this.cantRemoveChar[i];
			}
			canBeEmptyFormat += "]+$";
			canBeEmptyPattern = Pattern.compile(canBeEmptyFormat);
		}
 
		public void setCanBeEmpty(boolean b){
			this.canBeEmpty = b;
		}
 
		/**
                 * On enregistre le texte courant, on effectue le insertString, puis on récupère le nouveau texte et on vérifie qu'il correspond au Pattern.
                 * S'il ne corespond pas on efface le texte et on remet l'ancien.
                 */
		public void insertString(int offset, String text, AttributeSet a) throws BadLocationException{
			if(saveStringBeforeEmpty != null){
				super.insertString(0, saveStringBeforeEmpty, a);
				saveStringBeforeEmpty = null;
			}
			String olds = this.getText(0, this.getLength());
			super.insertString(offset, text, a);
			String news = this.getText(0, this.getLength());
 
			Matcher mnew = regFloat.matcher(news);
			if(!mnew.find()){
				// Si le nouveau texte ne 'match' pas le pattern
				// alors on remet l'ancien.
				super.remove(0, this.getLength());
				super.insertString(0, olds, a);
			}
 
			canBeEmptyRemoveAll();
		}
 
		/**
                 * On vérifie que l'on essaye pas d'effacer un carqctère inéfaçable.
                 * @see setUnRemovableChar()
                 */
		public void remove(int offs, int len) throws BadLocationException{
			boolean remove = true;
 
			if(offs < 0){
				super.remove(offs, len);
				return;
			}
 
			for(int i=0; i<cantRemoveChar.length && remove; i++){
				if(this.getText(0,getLength()).substring(offs, offs+len).indexOf(cantRemoveChar[i]) >= 0){
					remove = false;
				}
			}
 
 
			if(remove){
				super.remove(offs, len);
			}
 
			this.canBeEmptyRemoveAll();
 
		}
 
		/**
                 * Cette méthode vide efface tout le texte s'il ne reste que des caractères 'innéfaçable' et que canBeEmpty == true.
                 */
		private void canBeEmptyRemoveAll() throws BadLocationException{
			if(this.canBeEmpty){
				if(canBeEmptyPattern != null){
					Matcher me = canBeEmptyPattern.matcher(this.getText(0, this.getLength()));
					if(me.find()){
						this.saveStringBeforeEmpty = this.getText(0, this.getLength());
						super.remove(0, this.getLength());
					}
				}
			}
		}
 
	}
}

Le truc qui n'est pas super c'est qu'avec ces caractères non-effaçable, il faut faire vraiment gaffe à l'expression régulière du model ! Idem pour la remise de ces caractères après un effacement complet...
En plus, dans ton cas, lors que le champs est vidé et que l'on tape un chiffre, la virgule sera remise derrière ce chiffre mais le curseur sera aussi derrière la virgule... Mais enfin bon c'est déjà pas mal :lol: