Comment marquer JTable entrée de la cellule comme invalide?

Si je prends un JTable et spécifier une colonne classtype sur son modèle comme suit:

   DefaultTableModel model = new DefaultTableModel(columnNames, 100) {
       @Override
        public Class<?> getColumnClass(int columnIndex) {
            return Integer.class;
        }};

Puis à chaque fois qu'un utilisateur tente d'entrer un double valeur dans la table, Balançoire rejette automatiquement l'entrée et définit la cellule contour rouge.

Je veux le même effet se produire quand quelqu'un entre dans un "négatif ou 0' entrée de la cellule. J'ai obtenu ceci:

    @Override
    public void setValueAt(Object val, int rowIndex, int columnIndex) {
       if (val instanceof Number && ((Number) val).doubleValue() > 0) {
              super.setValueAt(val, rowIndex, columnIndex);
            } 
       }
   }

Cela empêche la cellule à partir de l'acceptation de toute non-valeurs positives, mais il se complique pas définir la couleur de rouge et de quitter la cellule comme modifiable.

J'ai essayé de regarder comment JTable fait, le rejet par défaut, mais je n'arrive pas à le trouver.

Comment puis-je faire rejeter la non-entrée positive de la même façon, il rejette la non-entrée entière?

Grâce

OriginalL'auteur Cuga | 2011-09-23

La private static de la classe JTable.GenericEditor utilise l'introspection pour attraper les exceptions soulevées par la construction spécifique Number sous-classes invalides String valeurs. Si vous n'avez pas besoin d'un tel comportement générique, envisager la création d' PositiveIntegerCellEditor comme une sous-classe de DefaultCellEditor. Votre stopCellEditing() méthode serait en conséquence plus simple.

Addendum: mis à Jour pour utiliser RIGHT l'alignement et la commune de code d'erreur.

Addendum: Voir aussi l'Aide d'un Éditeur de Valider Texte Entrée par l'Utilisateur.

Comment marquer JTable entrée de la cellule comme invalide?

    private static class PositiveIntegerCellEditor extends DefaultCellEditor {

    private static final Border red = new LineBorder(Color.red);
    private static final Border black = new LineBorder(Color.black);
    private JTextField textField;

    public PositiveIntegerCellEditor(JTextField textField) {
        super(textField);
        this.textField = textField;
        this.textField.setHorizontalAlignment(JTextField.RIGHT);
    }

    @Override
    public boolean stopCellEditing() {
        try {
            int v = Integer.valueOf(textField.getText());
            if (v < 0) {
                throw new NumberFormatException();
            }
        } catch (NumberFormatException e) {
            textField.setBorder(red);
            return false;
        }
        return super.stopCellEditing();
    }

    @Override
    public Component getTableCellEditorComponent(JTable table,
        Object value, boolean isSelected, int row, int column) {
        textField.setBorder(black);
        return super.getTableCellEditorComponent(
            table, value, isSelected, row, column);
    }
}

Merci c'est beaucoup plus propre. J'ai fait revenir et de mettre à jour mon code pour être moins générique, depuis que je suis à la recherche de l'utiliser dans un endroit où je pourrais le contrôle de son utilisation.
Voir aussi ce autres.
hey trashgod est-ce une bonne idée d'utiliser un documentFilter à d'autres de ne pas laisser l'utilisateur les types?
Oui, selon le contexte; autrement, un bip boîte rouge peut être un peu ennuyeux. 🙂
Je pensais aussi que si vous avez votre propre AbstractTableModel dans setValueAt(row,column) vous pouvez valider si c'est une logique d'entreprise, mais alors vous perdez bip boîte rouge 😛

OriginalL'auteur trashgod

J'ai tout compris. Remplacer le DefaultCellEditor et retour false /la frontière au rouge si le numéro n'est pas positif.

Malheureusement, depuis JTable.GenericEditor est static w/default portée, je ne suis pas en mesure de remplacer la GenericEditor pour fournir cette fonctionnalité et de la ré-implémenter w/un peu de bricolage, sauf si quelqu'un a une meilleure façon de le faire, ce que je voudrais entendre.

    @SuppressWarnings("serial")
class PositiveNumericCellEditor extends DefaultCellEditor {
Class[] argTypes = new Class[]{String.class};
java.lang.reflect.Constructor constructor;
Object value;
public PositiveNumericCellEditor() {
super(new JTextField());
getComponent().setName("Table.editor");
((JTextField)getComponent()).setHorizontalAlignment(JTextField.RIGHT);
}
public boolean stopCellEditing() {
String s = (String)super.getCellEditorValue();
if ("".equals(s)) {
if (constructor.getDeclaringClass() == String.class) {
value = s;
}
super.stopCellEditing();
}
try {
value = constructor.newInstance(new Object[]{s});
if (value instanceof Number && ((Number) value).doubleValue() > 0)
{
return super.stopCellEditing();
} else {
throw new RuntimeException("Input must be a positive number."); 
}
}
catch (Exception e) {
((JComponent)getComponent()).setBorder(new LineBorder(Color.red));
return false;
}
}
public Component getTableCellEditorComponent(JTable table, Object value,
boolean isSelected,
int row, int column) {
this.value = null;
((JComponent)getComponent()).setBorder(new LineBorder(Color.black));
try {
Class type = table.getColumnClass(column);
if (type == Object.class) {
type = String.class;
}
constructor = type.getConstructor(argTypes);
}
catch (Exception e) {
return null;
}
return super.getTableCellEditorComponent(table, value, isSelected, row, column);
}
public Object getCellEditorValue() {
return value;
}
}

+1 pour genericity. Vous pourriez essayer de passer un Class Littérale d'Exécution comme Type de Jeton pour le constructeur, mais il n'est pas particulièrement simple.

OriginalL'auteur Cuga

Ce code est une petite amélioration de la accepté de répondre. Si l'
l'utilisateur ne peut pas entrer n'importe quelle valeur, en cliquant sur une autre cellule
lui permettre de sélectionner une autre cellule. La solution retenue n'est pas
permettre cela.

@Override
public boolean stopCellEditing() {
String text = field.getText();
if ("".equals(text)) {
return super.stopCellEditing();
}
try {
int v = Integer.valueOf(text);
if (v < 0) {
throw new NumberFormatException();
}            
} catch (NumberFormatException e) {
field.setBorder(redBorder);
return false;
}
return super.stopCellEditing();
}

Cette solution vérifie texte vide. Dans le cas d'un texte vide, nous en appelons à la stopCellEditing() méthode.

OriginalL'auteur Jan Bodnar

Vous devez vous connecter pour publier un commentaire.