Comment utiliser personnalisée JTable cellule de l'éditeur et de rendu de cellule

J'ai créé une JTable avec une table personnalisée de rendu et de cellule personnalisé éditeur qui donne le résultat dans l'image

J'ai créé le panneau indiqué dans le premier tableau, les cellules à l'aide d'une catégorie distincte qui s'étendait Composite. et ajouter les valeurs de la table comme,

        tbl.setCellEditor(new customCell());
        tbl.getColumnModel().getColumn(0).setCellRenderer(new customCell());

        DefaultTableModel dtm = (DefaultTableModel) tbl.getModel();

        Vector v = new Vector();
        v.add(new Panel());
        v.add("Test");
        dtm.addRow(v);

        v.clear();
        v.add(new Panel());
        v.add("Test 2");
        dtm.addRow(v);

Et c'est ma table de classe personnalisée pour créer cette table,

class customCell extends DefaultTableModel implements TableCellRenderer, TableCellEditor {

        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
            Panel p = new Panel();            
            table.setRowHeight(row, p.getHeight());
            return p;
        }

        public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {

            return new Panel();
        }

        public Object getCellEditorValue() {
            return "";
        }

        public boolean isCellEditable(EventObject anEvent) {
            throw new UnsupportedOperationException("Not supported yet.");
        }

        public boolean shouldSelectCell(EventObject anEvent) {
            return true;
        }

        @Override
        public boolean isCellEditable(int rowIndex, int columnIndex) {
            return true;
        }

        public boolean stopCellEditing() {
            return true;
        }

        public void cancelCellEditing() {
            throw new UnsupportedOperationException("Not supported yet.");
        }

        public void addCellEditorListener(CellEditorListener l) {
            throw new UnsupportedOperationException("Not supported yet.");
        }

        public void removeCellEditorListener(CellEditorListener l) {
            throw new UnsupportedOperationException("Not supported yet.");
        }
    }

Mon problème est la pensée, le panneau est illustré comme je m'y attendais je ne peut pas taper dans le champ de texte ou de changement de case à cocher ou cliquez sur le bouton. merci de me dire comment résoudre ce problème.

OriginalL'auteur Harsha | 2012-08-08

avoir à ajouter de la bonne LayoutManager, Editable/non_Editable propriétés déjà visible JPanel

laisser profiter de

import java.awt.*;
import java.awt.event.*;
import java.util.EventObject;
import javax.swing.*;
import javax.swing.table.*;
public class PanelInTable {
private JFrame frame;
private JTable compTable = null;
private PanelTableModel compModel = null;
private JButton addButton = null;
public static void main(String args[]) {
try {
UIManager.setLookAndFeel("com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel");
//UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (Exception fail) {
}
SwingUtilities.invokeLater(() -> {
new PanelInTable().makeUI();
});
}
public void makeUI() {
compTable = CreateCompTable();
JScrollPane CompTableScrollpane = new JScrollPane(compTable, 
JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
JPanel bottomPanel = CreateBottomPanel();
frame = new JFrame("Comp Table Test");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.add(CompTableScrollpane, BorderLayout.CENTER);
frame.add(bottomPanel, BorderLayout.SOUTH);
frame.setPreferredSize(new Dimension(800, 400));
frame.setLocation(150, 150);
frame.pack();
frame.setVisible(true);
}
public JTable CreateCompTable() {
compModel = new PanelTableModel();
compModel.addRow();
JTable table = new JTable(compModel);
table.setRowHeight(new CompCellPanel().getPreferredSize().height);
table.setTableHeader(null);
PanelCellEditorRenderer PanelCellEditorRenderer = new PanelCellEditorRenderer();
table.setDefaultRenderer(Object.class, PanelCellEditorRenderer);
table.setDefaultEditor(Object.class, PanelCellEditorRenderer);
return table;
}
public JPanel CreateBottomPanel() {
addButton = new JButton("Add Comp");
addButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent ae) {
Object source = ae.getSource();
if (source == addButton) {
compModel.addRow();
}
}
});
JPanel panel = new JPanel(new GridBagLayout());
panel.add(addButton);
return panel;
}
}
class PanelCellEditorRenderer extends AbstractCellEditor implements 
TableCellRenderer, TableCellEditor {
private static final long serialVersionUID = 1L;
private CompCellPanel renderer = new CompCellPanel();
private CompCellPanel editor = new CompCellPanel();
@Override
public Component getTableCellRendererComponent(JTable table, Object value, 
boolean isSelected, boolean hasFocus, int row, int column) {
renderer.setComp((Comp) value);
return renderer;
}
@Override
public Component getTableCellEditorComponent(JTable table, Object value, 
boolean isSelected, int row, int column) {
editor.setComp((Comp) value);
return editor;
}
@Override
public Object getCellEditorValue() {
return editor.getComp();
}
@Override
public boolean isCellEditable(EventObject anEvent) {
return true;
}
@Override
public boolean shouldSelectCell(EventObject anEvent) {
return false;
}
}
class PanelTableModel extends DefaultTableModel {
private static final long serialVersionUID = 1L;
@Override
public int getColumnCount() {
return 1;
}
public void addRow() {
super.addRow(new Object[]{new Comp(0, 0, "", "")});
}
}
class Comp {
public int type;
public int relation;
public String lower;
public String upper;
public Comp(int type, int relation, String lower, String upper) {
this.type = type;
this.relation = relation;
this.lower = lower;
this.upper = upper;
}
}
class CompCellPanel extends JPanel {
private static final long serialVersionUID = 1L;
private JLabel labelWith = new JLabel("With ");
private JComboBox typeCombo = new JComboBox(new Object[]
{"height", "length", "volume"});
private JComboBox relationCombo = new JComboBox(new Object[]
{"above", "below", "between"});
private JTextField lowerField = new JTextField();
private JLabel labelAnd = new JLabel(" and ");
private JTextField upperField = new JTextField();
private JButton removeButton = new JButton("remove");
public CompCellPanel() {
setLayout(new BoxLayout(this, BoxLayout.X_AXIS));
relationCombo.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
enableUpper(relationCombo.getSelectedIndex() == 2);
}
});
enableUpper(false);
removeButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
JTable table = (JTable) SwingUtilities.getAncestorOfClass(
JTable.class, (Component) e.getSource());
int row = table.getEditingRow();
table.getCellEditor().stopCellEditing();
((DefaultTableModel) table.getModel()).removeRow(row);
}
});
add(labelWith);
add(typeCombo);
add(relationCombo);
add(lowerField);
add(labelAnd);
add(upperField);
add(Box.createHorizontalStrut(100));
add(removeButton);
}
private void enableUpper(boolean enable) {
labelAnd.setEnabled(enable);
upperField.setEnabled(enable);
}
public void setComp(Comp Comp) {
typeCombo.setSelectedIndex(Comp.type);
relationCombo.setSelectedIndex(Comp.relation);
lowerField.setText(Comp.lower);
upperField.setText(Comp.upper);
enableUpper(Comp.relation == 2);
}
public Comp getComp() {
return new Comp(typeCombo.getSelectedIndex(), 
relationCombo.getSelectedIndex(), 
lowerField.getText(), upperField.getText());
}
}

l'arrêt de la modifier appartient à l'éditeur, non pas dans le panneau. Aussi, gâcher le modèle de l'extérieur actionListener est défendable...; -)
je vous remercie pour la grande pêche, btw, ce code est révisé par votre honnêteté plus de 3 fois, j'ai essayé de déplacer et à utiliser l'Action de JTable faite par Rob(je pense que rien de mieux, gratuit et plus simple), pas de changements et d'événements sont déclenchés assez similair,
Merci beaucoup mKorbel
pourquoi êtes-vous étendre AbstractCellEditor
Simionescu, car ....... ours polaire??? :-), Je suis de voir que, comme la plus simple, compacte pour l'exemple de code dans SSCCE forn, collé à un forum public

OriginalL'auteur mKorbel

14

Je suggère fortement de réutiliser les fonctionnalités disponibles dans la table par défaut les convertisseurs et les éditeurs, comme il y a beaucoup de choses de mal avec votre code
1. Veuillez diviser votre éditeur de moteur de rendu et de modèle de table. De les avoir tous dans la même classe est juste bizarre
2. Pour votre moteur de rendu, de ne pas créer de nouvelles instances d'un Component à chaque fois. Au lieu de cela, la réutilisation d'un même composant et ne modifier que Component dans le getTableCellRendererComponent méthode
3. En va de même pour l'éditeur Component
4. Étendre un éditeur par défaut au lieu de la mise en œuvre de méthodes avec UnsupportedOperationExceptions, ou par tout les retours à vide Strings
De back-up de mon point de suite, une petite citation de la Les éditeurs de la partie dans le JTable tutoriel:

Ce que si vous souhaitez spécifier un éditeur autre qu'un champ de texte, case à cocher, ou zone de liste modifiable? Comme DefaultCellEditor ne prend pas en charge d'autres types de composants, vous devez faire un peu plus de travail. Vous devez créer une classe qui implémente l'TableCellEditor interface. Le AbstractCellEditor classe est un bon super-classe à utiliser. Il met en œuvre TableCellEditor de superinterface, CellEditor, vous permet d'économiser les problèmes de mise en œuvre de l'événement de tir code nécessaire pour la cellule éditeurs.

Votre cellule éditeur de classe doit définir au moins deux méthodes — getCellEditorValue et getTableCellEditorComponent. Le getCellEditorValue méthode, requis par CellEditor, renvoie la cellule de la valeur actuelle. Le getTableCellEditorComponent méthode, requis par TableCellEditor, doit configurer et retour le composant que vous souhaitez utiliser comme éditeur.

Comme l'a expliqué clairement là, vous devez mettre en œuvre l'événement de tir code:

vous permet d'économiser les problèmes de mise en œuvre de l'événement de tir code nécessaire pour la cellule éditeurs.

qui vous clairement négligé. Donc, je conseille de commencer à partir de AbstractCellEditor au lieu de la mise en œuvre de l'interface à partir de zéro

pouvez-vous donner un exemple complet avec code?

OriginalL'auteur Robin

Vous devez vous connecter pour publier un commentaire.