[SWING] : comment limiter un JTextField à 25 lettres capitales ??? [Résolu]

Messages postés
12
Date d'inscription
dimanche 1 avril 2001
Dernière intervention
16 juillet 2007
- - Dernière réponse : achkarinho
Messages postés
4
Date d'inscription
jeudi 19 mars 2009
Dernière intervention
25 juin 2012
- 4 juin 2009 à 16:22
Bonjour,

je souhaite limiter un champ de saisies à 25 lettres en capitale, avec le premier caractère obligatoire.
J'ai essayé d'utiliser un JFormattedTextField avec un MaskFormatter("UUUUUUUUUUUUUUUUUUUUUUUUU") mais si j'écris moins de 25 lettres, soit il m'efface la donnée saisie, soit si je décide de modifier le comportement par défaut et de commiter, il me complète avec des blancs...

Sinon, j'ai trouvé le code suivant pour limiter un JTextField à un certain nombre de caractères : «
class JTextField2 extends JTextField {
private int maxLength;

JTextField2(String text, int columns) {
super(text, columns);
maxLength = columns;if (maxLength <0) maxLength -1;
addFocusListener(this);
}

protected Document createDefaultModel() {
return new PlainDocument2();
}

class PlainDocument2 extends PlainDocument {
public void insertString(int offset, String str, AttributeSet attr)
throws BadLocationException {
if (str == null) return;
if (maxLength == -1 || getLength() + str.length() <= maxLength) {
super.insertString(offset, str, attr);
}
}
}
}
», mais je ne peux pas m'assurer que l'utilisateur ne saisit que des lettres en capitale.

Comprenez-vous mon problème ?
Comment puis-je faire ?
Avez-vous une idée ?

Merci beaucoup,
F.
Afficher la suite 

Votre réponse

7 réponses

Messages postés
12
Date d'inscription
dimanche 1 avril 2001
Dernière intervention
16 juillet 2007
0
Merci
Merci pour ta réponse « Ambisious developper » mais ton code ne fait qu'une partie du travail : il convertit la chaîne en majuscules.

Cependant, ton code ne limite pas la saisie à 25 caractères et surtout, il n'empêche pas la saisie de caractère non alphabétique.
Est-ce que je me trompe ?

Merci pour votre aide,
F.
Commenter la réponse de cs_Foub
Messages postés
2333
Date d'inscription
samedi 28 février 2004
Dernière intervention
26 juillet 2013
0
Merci
Salut:

Pour limiter le nombre de caractères saisies à 25 c'est logique que ce ci soit validé lorsqu'on on terminé le saisie, càd lorsque:



1. le champ de texte perd le focus



2. tu appuie sur un bouton de validation



Donc tu peux gérer cette contrainte de taille à travers un listener approprié.




_________________________________________________________________________________
A.B. :

"Qui veut faire quelque chose trouve un moyen. - Qui ne veut rien faire trouv
Commenter la réponse de Ombitious_Developper
Messages postés
2333
Date d'inscription
samedi 28 février 2004
Dernière intervention
26 juillet 2013
0
Merci
Salut inspire toi:

https://lists.xcf.berkeley.edu/lists/advanced-java/1999-November/003269.html



http://webdev.apl.jhu.edu/~rbe/java/JTextField/JTextField.pdf



http://forum.java.sun.com/thread.jspa?threadID=194553&messageID=637676




_________________________________________________________________________________
A.B. :


"Qui veut faire quelque chose trouve un moyen. - Qui ne veut rien faire trouve une excuse.
Commenter la réponse de Ombitious_Developper
Messages postés
5307
Date d'inscription
dimanche 4 mai 2003
Dernière intervention
14 décembre 2018
0
Merci
Salut,

si tu veux tout le traitement change le code de  [auteurdetail.aspx?ID=237842 Ombitious_Developper]par :

public class Document extends PlainDocument {
    private static final long    serialVersionUID    = 352091261670024482L;
    private int                  maxChar             = 0;

    public Document(int maxChar) {
        super();
        this.maxChar = maxChar;
    }
       
    public void insertString(int offset, String str,
            AttributeSet attributeSet) throws BadLocationException {
        if ((getLength() + str.length()) > maxChar){
            Toolkit.getDefaultToolkit().beep();//joue un petit son
            return;
        }
        super.insertString(offset, str.toUpperCase(), attributeSet);
    }
}

JTextField textField = ...;
textField.setDocument (new Document(25));

------------------------------------
"On n'est pas au resto : ici on ne fait pas dans les plats tout cuits ..."

WORA
Commenter la réponse de Twinuts
Messages postés
12
Date d'inscription
dimanche 1 avril 2001
Dernière intervention
16 juillet 2007
0
Merci
Merci Ombitious, ta technique fonctionne à merveille.
Pour ceux qui seraient intéressés, voici mon code :

/**
 * Cette classe se propose de contrôler la saisie d'un champ JTextField
 * qui utiliserait ce document.
 * Ainsi,
 *         - on limite le nombre de caractères saisissables dans le champ
 *         - seuls les caractères alphabétiques (lettres) sont autorisés auquel on ajoute les
 *           caractères présents dans la liste listeCaracteresAutorisees et auquel on retranche
 *           ceux issues de la liste listeCaracteresInterdits.
 */
public class PlainDocumentLettresEnMajuscules extends PlainDocument {
    private static final long serialVersionUID = 0L;
    private int maxlength;
    private Set<Character> listeCaracteresAutorisees;
    private Set<Character> listeCaracteresInterdits;
    
    /**
     * Constructeur de la classe PlainDocumentLettresEnMajuscules permettant de controler la saisie
     * dans un champ texte.
     * @param maxlength nombre maximal de caractères pour ce champ ; mettre 0 pour une saisie illimitée.
     * @param listeCaracteresAutorisees : liste de caractères autorisés en plus des caractères alphabétiques (lettres).
     * @param listeCaracteresInterdits : liste de caractères interdits, en plus de ceux qui ne sont pas des caractères alphabétiques.
     */
    public PlainDocumentLettresEnMajuscules(int maxlength, Set<Character> listeCaracteresAutorisees, Set<Character> listeCaracteresInterdits) {
        if (maxlength < 0) {
            throw new IllegalArgumentException("La nombre maximal de caractères autorisé pour ce champ ne peut-être une valeur négative.");
        } else {
            this.maxlength = maxlength;
        }
        
        if (listeCaracteresAutorisees == null) {
            this.listeCaracteresAutorisees = new HashSet<Character>();
        } else {
            this.listeCaracteresAutorisees = listeCaracteresAutorisees;
        }
        
        if (listeCaracteresInterdits == null) {
            this.listeCaracteresInterdits = new HashSet<Character>();
        } else {
            this.listeCaracteresInterdits = listeCaracteresInterdits;
        }
    }
    
    /**
     * Action à effectuer lors de l'ajout d'un caractère dans le champ de saisie.
     */
    public void insertString(int off, String s, AttributeSet a) throws BadLocationException {
       int nbCaracterePresentActuellementDansLeChamp = this.getLength();
       
       // Si on a atteint la limite, on quitte...       if ((s null)||((nbCaracterePresentActuellementDansLeChamp maxlength) &amp;&amp; (maxlength > 0)) ) {
           // aucun caractère ne sera ajouté dans le champ
           // on émet un petit bruit pour signaler que l'on a atteint la limite
           // du nombre de caractères.
           Toolkit.getDefaultToolkit().beep();
           return;
       } else {
           // On détecte la chaîne à ajouter
           StringBuffer str = new StringBuffer();
           
           boolean isLettre;           int i 0, nb s.length();
           for (; i < nb; i++) {
               Character c = s.charAt(i);
               isLettre = Character.isLetter(c);
               
               // Si le caractère est une lettre et qu'il ne fait pas partie des caractères
               // interdits, on l'ajoute à la chaîne.
               if ((isLettre) &amp;&amp; (!listeCaracteresInterdits.contains(c))) {
                   str.append( new String(c + "").toUpperCase() );
               } else if ((isLettre == false) &amp;&amp; ( (listeCaracteresAutorisees.contains(c)) ))  {
                   str.append( new String(c + "") );
               }
           }
           
           if (str.toString().equals("")) {
               return;
           } else if ((maxlength == 0)||((nbCaracterePresentActuellementDansLeChamp + str.length()) <= maxlength)) {
               super.insertString(off, str.toString(), a);
           } else {
               // Emission d'un bruit car on a atteint la limite du nombre de caractères autorisés.
               Toolkit.getDefaultToolkit().beep();
               // on doit couper la chaîne à insérer car on dépasserait le nombre de caractères autorisés.
               super.insertString(off, str.substring(0, (maxlength - nbCaracterePresentActuellementDansLeChamp) ), a);
           }
       }
    }
}


Ensuite, je me suis créé un JTextField personnel qui attribue le document créé précédemment :

/**
 * Ce composant propose la saisie de caractères alphabétiques (lettres)
 * en capitale. 
 */
public class JTextFieldForceLettresEnCapitale extends JTextField {
    private static final long serialVersionUID = 0L;
    private static int TAILLE_PAR_DEFAUT = 20;
    private Set<Character> listeCaracteresAutorisees = new HashSet<Character>();
    private Set<Character> listeCaracteresInterdits = new HashSet<Character>();
    
    /**
     * Constructeur de la classe JTextFieldForceLettresEnCapitale qui permet de spécifier le nombre
     * maximal de caractères autorisés pour ce champ.
     * @param maxLength nombre maximal de caractères autorisés pour ce champ ; mettre 0 pour une saisie illimité.
     */
    public JTextFieldForceLettresEnCapitale(int maxLength) {
        super();
        this.setDocument(new PlainDocumentLettresEnMajuscules(maxLength, listeCaracteresAutorisees, listeCaracteresInterdits));
    }
    
    /**
     * Constructeur de la classe JTextFieldForceLettresEnCapitale.
     * Le nombre maximal de caractères autorisés pour ce champ est définit par défaut à 20.
     * La chaîne de caractères passé en paramètre valorisera le champ à condition que cette dernière
     * respecte les caractères autorisés.
     * @param text Chaîne valorisant le champ.
     */
    public JTextFieldForceLettresEnCapitale(String text) {
        super();
        this.setDocument(new PlainDocumentLettresEnMajuscules(JTextFieldForceLettresEnCapitale.TAILLE_PAR_DEFAUT, listeCaracteresAutorisees, listeCaracteresInterdits));
        this.setText(text);
    }
    
    /**
     * Constructeur de la classe JTextFieldForceLettresEnCapitale qui permet de définir un nombre maximal
     * de caractères autorisés pour ce champ ainsi que la chaîne de caractères permettant de le prévaloriser.
     * @param maxLength nombre maximal de caractères autorisés pour ce champ ; mettre 0 pour une saisie illimité.
     * @param text chaîne de caractères prévalorisant le champ.
     */
    public JTextFieldForceLettresEnCapitale(int maxLength, String text) {
        super();
        this.setDocument(new PlainDocumentLettresEnMajuscules(maxLength, listeCaracteresAutorisees, listeCaracteresInterdits));
        this.setText(text);
    }
    
    /**
     * Ajoute un caractère normallement interdit à la liste des caractères autorisés.
     * @param c caractère à ajouter à cette liste.
     */
    public void ajouterCaractereAutorise(char c) {
        listeCaracteresAutorisees.add(c);
    }

    /**
     * Retire un caractère normallement interdit à la liste des caractères autorisés.
     * @param c caractère à enlever de cette liste.
     */
    public void enleverCaractereAutorise(char c) {
        listeCaracteresAutorisees.remove(c);
    }
    
    /**
     * On efface les caractères présents dans la liste
     * des caractères autorisés.
     */
    public void clearListeCaracteresAutorises() {
        listeCaracteresAutorisees.clear();
    }
    
    /**
     * Ajoute un caractère normallement autorisé à la liste des caractères interdits.
     * @param c caractère à ajouter à cette liste.
     */
    public void ajouterCaractereInterdit(char c) {
        listeCaracteresInterdits.add(c);
    }

    /**
     * Retire un caractère normallement autorisé à la liste des caractères interdits.
     * @param c caractère à enlever de cette liste.
     */
    public void enleverCaractereInterdit(char c) {
        listeCaracteresInterdits.remove(c);
    }
    
    /**
     * On efface les caractères présents dans la liste
     * des caractères interdits.
     */
    public void clearListeCaracteresInterdits() {
        listeCaracteresInterdits.clear();
    }
}


Walla,
et tout fonctionne comme je le souhaitais :D
Merci à tous pour votre aide.

F.
Commenter la réponse de cs_Foub
Messages postés
4
Date d'inscription
jeudi 19 mars 2009
Dernière intervention
25 juin 2012
0
Merci
merci pour le code [../auteur/FOUB/427.aspx Foub] et bien joué [../auteur/OMBITIOUSDEVELOPPER/237842.aspx Ombitious_Developper]
Commenter la réponse de achkarinho
Messages postés
2333
Date d'inscription
samedi 28 février 2004
Dernière intervention
26 juillet 2013
-1
Merci
Salut:

Pour faciliter la tâche des utilisateurs de façon à ne pas saisir que des lettres en majuscules il faut que tu associes un éditeur à ton JTextField en modifiant l'objet Document qui lui est associé.



Illustration:




public class UpperCaseDocument extends PlainDocument {
    public void insertString(int offset,
                             String string,
                             AttributeSet attributeSet) {
        string = string.toUpperCase();
        super.insertString(offset, string, attributeSet);
    }
}





JTextField textField = ...;

textField.setDocument (new UpperCaseDocument ());




__________________________________________________________
A.B. :  La lumière voyage plus vite que le son. C'est pourquoi certaines personnes paraissent brillantes jusqu'à ce qu'elles commencent à parler ...
Commenter la réponse de Ombitious_Developper

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.