Comment mettre en œuvre l'interface graphique dynamique bat

Question

Tout d'abord, des excuses pour quelque chose d'affichage peut-être un peu trop sembler spécifique, mais je ne suis pas très expérimenté avec Swing, et ne peut pas trouver de bons exemples qui correspondent à mes besoins.

Je suis en train de déterminer la meilleure façon de mettre en œuvre l'une GUI dynamique pour le choix des critères de filtrage dans Swing:

Le modèle sous-jacent est une classe contenant une liste de critères qui peuvent être réduits à néant (à savoir appliqué avec un NOT-préfixe), et une propriété indiquant si ceux-ci doivent être combinées avec AND ou OR.

L'interface graphique permettant à l'utilisateur d'ajouter, modifier ou supprimer des critères et sélectionner l'opérateur de combinaison (et / ou). Le premier critérium aurait naturellement pas une combinaison sélecteur, et les critères suivants troisième et serait tout simplement utiliser la même combinaison que l'opérateur le second.

Les boutons X à droite serait utilisé pour supprimer un critérium. Lorsque le Add-bouton est enfoncé, une nouvelle gamme de composants serait ajouté au fond. Comme des modifications sont apportées, celles-ci seraient reflétées dans le modèle sous-jacent.

Bien sûr, je pourrais mettre en œuvre ce tout à fait « primitively » en ajoutant simplement des composants à un JPanel puis mettre à jour le modèle en conséquence, mais je préférerais une solution plus propre, tel que celui fourni par un TableModel.

Je me demande donc si une table avec une coutume TableModel et TableCellRenderer / éditeur serait la meilleure approche, ou s'il y a une meilleure façon de mettre en œuvre quelque chose comme ça. Si la table est en effet la meilleure approche, je vous serais reconnaissant de quelques conseils sur la façon dont on pourrait utiliser TableCellRenderers ou -Editors pour y parvenir.

Merci à l'avance.

Answer 1

exemple seulement, tout est codé en dur, pour une bonne compréhension

EDIT:

de kleopatra remarqué, déplacé JTable # fireTableDataChanged () de ActionListener au TableModel, modifié tous les noms de classe commencent par lowerCase

import java.awt.*;
import java.awt.event.*;
import java.util.EventObject;
import javax.swing.*;
import javax.swing.table.*;

public class ComponentTableTest {

    private JFrame frame;
    private JTable CompTable = null;
    private CompTableModel CompModel = null;
    private JButton addButton = null;

    public static void main(String args[]) {
        SwingUtilities.invokeLater(new Runnable() {

            @Override
            public void run() {
                new ComponentTableTest().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 CompTableModel();
        CompModel.addRow();
        JTable table = new JTable(CompModel);
        table.setRowHeight(new CompCellPanel().getPreferredSize().height);
        table.setTableHeader(null);
        CompCellEditorRenderer compCellEditorRenderer = new CompCellEditorRenderer();
        table.setDefaultRenderer(Object.class, compCellEditorRenderer);
        table.setDefaultEditor(Object.class, compCellEditorRenderer);
        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();
                    //CompModel.fireTableDataChanged(); // moved to TableModel
                }
            }
        });
        JPanel panel = new JPanel(new GridBagLayout());
        panel.add(addButton);
        return panel;
    }
}

class CompCellEditorRenderer 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 CompTableModel 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, "", "")});
        //super.fireTableDataChanged();
    }
}

class Comp {

    int type;
    int relation;
    String lower;
    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");

    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());
    }
}

Answer 2

Je pense que cette coutume TableModel et TableCellRenderer / Editor est le meilleur choix. http://download.oracle.com/javase/tutorial/uiswing/components /table.html Ce serait bon pour commencer.

Answer 3

ajouter tous les composants pour un critère de recherche à un panneau et ajouter / retirer le panneau spécifique. Je ne pense pas TableModel est un bon choix ici.

Answer 4

Netbeans a un ui agréable qui fait quelque chose de semblable à ce que vous décrivez:

Pourquoi ne pas se tenir debout sur les épaules de géants? Les panneaux Netbeans air agréable et bien. La mise en œuvre est encore séparé proprement entre ui et code modèle. Si j'étais dans vos chaussures (et il a été Juin 2011), je base ma solution ici la source:

http: / /hg.netbeans.org/main/file/14d339767aef/tasklist.ui/src/org/netbeans/modules/tasklist/filter

KeywordPanel.java contient ce commentaire cryptique: «L'interface graphique est basée sur celle de l'outil de messagerie de Mozilla »

Je me demande ce qui pourrait être?

Désolé pour la réponse tardive.