En maintenant le rendu de cellules JTable après la modification de cellule

dans un JTable, implémentant les capacités de rendu et d'édition personnalisées de cellules peut améliorer l'expérience utilisateur. Cependant, il est crucial de s'assurer que le formatage souhaité est conservé même après les opérations de modification.

Le problème

Après avoir mis en place un rendu de cellule personnalisé pour la mise en forme d'une colonne "Prix", les utilisateurs comprenaient une discrédité où le format de nombre a été perdu lors de la modification des cellules. Dans de tels scénarios, la valeur par défaut du rendu de cellule peut ne pas être appliquée une fois que l'édition est engagée.

La solution

pour maintenir le rendu personnalisé après la modification de la cellule, il est essentiel d'utiliser les déclencheurs et les classes d'événements. Lorsque l'édition se termine, la méthode EditStopped () de JTable collecte la nouvelle valeur via GetCelEditorValue (). Le modèle est ensuite notifié avec setValueat () et doit par la suite appeler FiTableCelLupDated (). Ce processus complet invoque le rendu, qui peut être étendu pour gérer les besoins de formatage spéciaux.

Considérations supplémentaires

Pour des exigences de formatage plus complexes, il est recommandé de considérer l'utilisation d'une instance du rendu personnalisé comme composant de l'éditeur lui-même. Cela permet un plus grand contrôle sur l'apparence et le comportement de la cellule, garantissant une mise en forme cohérente même après les modifications de la cellule.

Exemple

L'extrait de code suivant fournit un exemple d'implémentation qui montre comment formater les valeurs de devise en tant que nombres dans les cellules JTable. Le rendu personnalisé (CurrencyRenderer) gère le formatage des devises, tandis que l'éditeur personnalisé (CurrencyEditor) permet aux utilisateurs de modifier les valeurs tout en maintenant le formatage.

import java.awt.Component;
import java.awt.event.MouseEvent;
import java.text.NumberFormat;
import javax.swing.DefaultCellEditor;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.table.DefaultTableCellRenderer;

// Custom cell renderer for currency formatting
public class CurrencyRenderer extends DefaultTableCellRenderer {

    private NumberFormat formatter;

    public CurrencyRenderer(NumberFormat formatter) {
        this.formatter = formatter;
        setHorizontalAlignment(JLabel.RIGHT);
    }

    @Override
    public void setValue(Object value) {
        setText((value == null) ? "" : formatter.format(value));
    }
}

// Custom cell editor for currency input, maintaining the formatting
public class CurrencyEditor extends DefaultCellEditor {

    private NumberFormat formatter;
    private JTextField textField;

    public CurrencyEditor(NumberFormat formatter) {
        super(new JTextField());
        this.formatter = formatter;
        textField = (JTextField) getComponent();
        textField.setHorizontalAlignment(JTextField.RIGHT);
        textField.setBorder(null);
    }

    @Override
    public Object getCellEditorValue() {
        try {
            return new Double(textField.getText());
        } catch (NumberFormatException e) {
            return Double.valueOf(0);
        }
    }

    @Override
    public Component getTableCellEditorComponent(JTable table,
            Object value, boolean isSelected, int row, int column) {
        textField.setText((value == null)
                ? "" : formatter.format((Double) value));
        return textField;
    }
}

En incorporant ces techniques, les développeurs peuvent s'assurer que les capacités de rendu et d'édition de cellules personnalisées fonctionnent de manière transparente dans JTable, offrant une expérience de manipulation de données cohérente et conviviale.