Bonjour

J'ai un bouton qui affiche une JTable avec comme colonnes tout les attributs de mon enum.

J'ai un JButton qui affiche un JPopupMenu et qui affiche un JCheckBoxMenuItem.

J'aimerais pouvoir choisir quel attribut de mon enum j'affiche comme colonne dans mon Jtable.

Comment remplir ma JcheckBoxMenuItem avec les elements de mon enum ? Et comment pouvoir changer l'affichage de mes colonnes selon les croix de ma checkbox.

public class ToolBar extends JToolBar {

 
    private final JButton btnColonnes;
    
    final JCheckBoxMenuItem showhelp = new JCheckBoxMenuItem();
    final JPopupMenu popup = new JPopupMenu();

 add(btnColonnes = new JButton(new AbstractAction("Colonnes") {
            @Override
            public void actionPerformed(ActionEvent e) {
            	popup.show(btnColonnes,btnColonnes.getLocation().x, btnColonnes.getLocation().y);
            }
            
        }));
}

package tnr.ui.grid.components;

import com.sun.org.apache.xpath.internal.operations.Bool;
import tnr.domain.Difference;
import tnr.domain.Facture;

import javax.swing.*;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

public class Grid extends JPanel {
    private final BiConsumer<Difference, Boolean> onStatusChange;
    private final Model model;
    private final JTable grid;

    public Grid(Consumer<Difference> onSelection, BiConsumer<Difference, Boolean> onStatusChange) {
        super(new BorderLayout(0, 0));
        this.onStatusChange = onStatusChange;

        add(new JScrollPane(grid = new JTable(model = new Model())));
        grid.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        grid.setDefaultRenderer(String.class, new DifferenceHighlighter());
        grid.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                if ( e.getClickCount()!=2 || grid.getSelectedRow()<0) return;
                Difference difference = model.getDifferenceAt(grid.getSelectedRow());
                onSelection.accept(difference);
            }
        });
    }
    
    

    public void addDifference(Difference difference, boolean status) {
        model.add(difference, status);
    }

    private class DifferenceHighlighter extends DefaultTableCellRenderer {

        @Override
        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
            JLabel renderer = (JLabel) super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
            if ( model.isDifference(row, column) ) {
                renderer.setFont(renderer.getFont().deriveFont(Font.BOLD));
                renderer.setForeground(Color.RED);
            } else {
                renderer.setForeground(isSelected?table.getSelectionForeground():table.getForeground());
                renderer.setFont(renderer.getFont().deriveFont(Font.PLAIN));
            }
            return renderer;
        }
    }

    private class Model extends AbstractTableModel {
        private final List<Difference> lines = new ArrayList<>();
        private final Map<Difference, Boolean> statuses = new HashMap<>();
        // La dernière colonne est une case a cocher pour marquer comme "vu"
        private final int lastColumn = Facture.Attribute.values().length;

        Difference getDifferenceAt(int row) {
            return lines.get(row);
        }

        void add(Difference difference, boolean status) {
            this.lines.add(difference);
            this.statuses.put(difference, status);
            fireTableRowsInserted(this.lines.size()-1, this.lines.size());
        }

        boolean isDifference(int row, int column) {
            Facture.Attribute attribute = Facture.Attribute.values()[column];
            Difference difference = lines.get(row);
            return difference.contains(attribute);
        }

        @Override
        public int getRowCount() {
            return lines.size();
        }

        @Override
        public int getColumnCount() {
            return Facture.Attribute.values().length+1; // +1 pour "vu"
        }

        @Override
        public String getColumnName(int column) {
            return column==lastColumn
                    ? "Vu"
                    : Facture.Attribute.values()[column].name();
        }

        @Override
        public Class<?> getColumnClass(int column) {
            return column==lastColumn
                    ? Boolean.class
                    : String.class;
        }

        @Override
        public Object getValueAt(int rowIndex, int column) {
            Difference difference = lines.get(rowIndex);
            if ( column==lastColumn ) {
                return statuses.getOrDefault(difference, false);
            } else {
                Facture.Attribute attribute = Facture.Attribute.values()[column];
                // Le but final est d'avoir dans le tableau, les informations de la map du second flux
                // (mais seulement celle en ecart).
                return attribute.read(difference.right);
            }
        }

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

        @Override
        public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
            Difference difference = lines.get(rowIndex);
            statuses.put(difference, (Boolean) aValue);
            onStatusChange.accept(difference, (Boolean) aValue);
        }
    }
}

package tnr.ui.grid;

import tnr.domain.Difference;
import tnr.domain.Facture;
import tnr.ui.UserStorage;

import javax.swing.event.EventListenerList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Consumer;
import java.util.stream.Collectors;

public class GridModel {

    private final EventListenerList listeners = new EventListenerList();
    private final Map<String, Facture> facturesByUniqueId = new HashMap<>();
    private final Map<String, Difference> differences = new HashMap<>();
    private final UserStorage storage;
    private boolean comparisonInProgress = false;
    private Difference selected = null;

    public GridModel(UserStorage storage) {
        this.storage = storage;
    }

    int getParsedCount() {
        return facturesByUniqueId.size();
    }

    int getDifferencesCount() {
        return differences.size();
    }

    void addGridModelListener(GridModelListener listener) {
        listeners.add(GridModelListener.class, listener);
    }

    public void setComparisonStarted() {
        if ( comparisonInProgress ) return;

        differences.clear();
        facturesByUniqueId.clear();
        comparisonInProgress = true;
        fire(l -> l.onComparisonStarted());
    }

    boolean isComparisonInProgress() {
        return comparisonInProgress;
    }

    void setSelectedDifference(Difference difference) {
        if ( selected!=null && selected.equals(difference) ) return;

        this.selected = difference;
        fire(l -> l.onSelectionChanged(difference));
    }

    public void setComparisonFinished() {
        if ( !comparisonInProgress ) return;

        this.comparisonInProgress = false;
        fire(l -> l.onComparisonFinished(facturesByUniqueId.size(), differences.size()));
    }

    public void addFacture(Facture facture) {
        Facture other = facturesByUniqueId.get(facture.getUniqueId());
        if ( other==null ) {
            facturesByUniqueId.put(facture.getUniqueId(), facture);
        } else {
            Difference difference = new Difference(other, facture);
            if ( !difference.isEmpty() ) {
                differences.put(facture.getUniqueId(), difference);
                fire(l -> l.onDifferenceFound(difference));
            }
        }
    }

    // Gestion des Listerners
    
    private void fire(Consumer<GridModelListener> event) {
        GridModelListener[] lstnrs = listeners.getListeners(GridModelListener.class);
        for (int i = lstnrs.length - 1; i >= 0; i--) {
            event.accept(lstnrs[i]);
        }
    }

    // Gestion du Vu
    
    public void setStatus(Difference difference, Boolean accepted) {
        String[] ids = storage.getPreference("accepted_diffs").orElse("").split(";");
        String allButActualIds = Arrays.stream(ids).filter(id -> !id.equals(difference.getUniqueFactureId()))
                .collect(Collectors.joining(";"));
        if ( accepted ) {
            storage.setPreference("accepted_diffs", allButActualIds+";"+difference.getUniqueFactureId());
        } else {
            storage.setPreference("accepted_diffs", allButActualIds);
        }
    }

    public boolean getStatus(Difference difference) {
        String[] ids = storage.getPreference("accepted_diffs").orElse("").split(";");
        return Arrays.stream(ids).filter(id -> id.equals(difference.getUniqueFactureId()))
                .findAny().isPresent();
    }
    
    
    
}