Dépôt officiel du code source de l'ERP OpenConcerto

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2011-2019 OpenConcerto, by ILM Informatique. All rights reserved.

 *

 * The contents of this file are subject to the terms of the GNU General Public License Version 3

 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a

 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific

 * language governing permissions and limitations under the License.

 *

 * When distributing the software, include this License Header Notice in each file.

 */

 package org.openconcerto.sql.view.list;

import org.openconcerto.openoffice.XMLFormatVersion;

import org.openconcerto.openoffice.spreadsheet.SpreadSheet;

import org.openconcerto.sql.Log;

import org.openconcerto.sql.TM;

import org.openconcerto.sql.element.SQLComponent;

import org.openconcerto.sql.element.SQLElement;

import org.openconcerto.sql.element.SQLElementDirectory;

import org.openconcerto.sql.model.RowRef;

import org.openconcerto.sql.model.SQLField;

import org.openconcerto.sql.model.SQLRow;

import org.openconcerto.sql.model.SQLRowAccessor;

import org.openconcerto.sql.model.SQLRowValues;

import org.openconcerto.sql.model.SQLTable;

import org.openconcerto.sql.model.Where;

import org.openconcerto.sql.request.ComboSQLRequest.KeepMode;

import org.openconcerto.sql.request.ListSQLRequest;

import org.openconcerto.sql.request.UpdateBuilder;

import org.openconcerto.sql.users.User;

import org.openconcerto.sql.users.UserManager;

import org.openconcerto.sql.users.rights.TableAllRights;

import org.openconcerto.sql.view.FileTransfertHandler;

import org.openconcerto.sql.view.IListener;

import org.openconcerto.sql.view.RowMetadata;

import org.openconcerto.sql.view.RowMetadataCache;

import org.openconcerto.sql.view.list.IListeAction.ButtonsBuilder;

import org.openconcerto.sql.view.list.IListeAction.IListeEvent;

import org.openconcerto.sql.view.list.IListeAction.PopupBuilder;

import org.openconcerto.sql.view.list.IListeAction.PopupEvent;

import org.openconcerto.sql.view.list.RowAction.PredicateRowAction;

import org.openconcerto.sql.view.list.action.ListEvent;

import org.openconcerto.sql.view.list.action.SQLRowValuesAction;

import org.openconcerto.ui.FontUtils;

import org.openconcerto.ui.FormatEditor;

import org.openconcerto.ui.MenuUtils;

import org.openconcerto.ui.PopupMouseListener;

import org.openconcerto.ui.SwingThreadUtils;

import org.openconcerto.ui.list.selection.BaseListStateModel;

import org.openconcerto.ui.list.selection.ListSelection;

import org.openconcerto.ui.list.selection.ListSelectionState;

import org.openconcerto.ui.state.JTableStateManager;

import org.openconcerto.ui.table.AlternateTableCellRenderer;

import org.openconcerto.ui.table.ColumnSizeAdjustor;

import org.openconcerto.ui.table.TableColumnModelAdapter;

import org.openconcerto.ui.table.TablePopupMouseListener;

import org.openconcerto.ui.table.ViewTableModel;

import org.openconcerto.ui.table.XTableColumnModel;

import org.openconcerto.utils.CollectionUtils;

import org.openconcerto.utils.CompareUtils;

import org.openconcerto.utils.FormatGroup;

import org.openconcerto.utils.StringUtils;

import org.openconcerto.utils.TableModelSelectionAdapter;

import org.openconcerto.utils.TableSorter;

import org.openconcerto.utils.Tuple2;

import org.openconcerto.utils.cc.IPredicate;

import org.openconcerto.utils.cc.ITransformer;

import org.openconcerto.utils.convertor.StringClobConvertor;

import org.openconcerto.utils.text.BooleanFormat;

import java.awt.Color;

import java.awt.Component;

import java.awt.FlowLayout;

import java.awt.Font;

import java.awt.GridBagConstraints;

import java.awt.GridBagLayout;

import java.awt.Insets;

import java.awt.event.ActionEvent;

import java.awt.event.HierarchyEvent;

import java.awt.event.HierarchyListener;

import java.awt.event.KeyAdapter;

import java.awt.event.KeyEvent;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeListenerProxy;

import java.beans.PropertyChangeSupport;

import java.io.File;

import java.io.IOException;

import java.sql.Clob;

import java.sql.Time;

import java.sql.Timestamp;

import java.text.DateFormat;

import java.text.Format;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Date;

import java.util.EventObject;

import java.util.HashMap;

import java.util.HashSet;

import java.util.IdentityHashMap;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import java.util.concurrent.ExecutionException;

import java.util.function.BiFunction;

import javax.swing.AbstractAction;

import javax.swing.Action;

import javax.swing.DropMode;

import javax.swing.InputMap;

import javax.swing.JButton;

import javax.swing.JCheckBoxMenuItem;

import javax.swing.JComponent;

import javax.swing.JMenuItem;

import javax.swing.JPanel;

import javax.swing.JPopupMenu;

import javax.swing.JScrollPane;

import javax.swing.JTable;

import javax.swing.JTextField;

import javax.swing.KeyStroke;

import javax.swing.ListSelectionModel;

import javax.swing.SwingUtilities;

import javax.swing.SwingWorker;

import javax.swing.event.AncestorEvent;

import javax.swing.event.AncestorListener;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

import javax.swing.event.TableColumnModelEvent;

import javax.swing.event.TableModelEvent;

import javax.swing.event.TableModelListener;

import javax.swing.table.DefaultTableCellRenderer;

import javax.swing.table.TableCellRenderer;

import javax.swing.table.TableColumn;

import javax.swing.table.TableColumnModel;

import javax.swing.table.TableModel;

import net.jcip.annotations.GuardedBy;

/**

 * Une liste de lignes correspondant à une ListSQLRequest. Diagramme pour la sélection :

 * <img src="doc-files/listSelection.png"/><br/>

 *

 * @author ILM Informatique

 */

public final class IListe extends JPanel {

    static private final class LockAction extends SQLRowValuesAction {

        private final boolean lock;

        public LockAction(final boolean lock) {

            super(false, true, (e) -> {

                final List<Number> ids = e.getSelectedIDs();

                final SQLTable t = e.getTable();

                final UpdateBuilder update = new UpdateBuilder(t);

                update.setObject(SQLComponent.READ_ONLY_FIELD, lock ? SQLComponent.READ_ONLY_VALUE : SQLComponent.READ_WRITE_VALUE);

                final User user = UserManager.getUser();

                if (user != null)

                    update.setObject(SQLComponent.READ_ONLY_USER_FIELD, user.getId());

                update.setWhere(new Where(t.getKey(), ids));

                t.getDBSystemRoot().getDataSource().execute(update.asString());

                // don't fire too many times, as each one will cause UpdateQueue to issue a

                // request

                final Collection<? extends Number> fireIDs = ids.size() < 12 ? ids : Collections.singleton(SQLRow.NONEXISTANT_ID);

                for (final Number fireID : fireIDs)

                    t.fireTableModified(fireID.intValue(), update.getFieldsNames());

            });

            this.setName(TM.tr(lock ? "ilist.lockRows" : "ilist.unlockRows"));

            this.lock = lock;

        }

        @Override

        public boolean enabledFor(ListEvent evt) {

            boolean hasRight = TableAllRights.currentUserHasRight(this.lock ? TableAllRights.USER_UI_LOCK_ROW : TableAllRights.USER_UI_UNLOCK_ROW, evt.getTable());

            return !evt.getSelectedRowAccessors().isEmpty() && hasRight;

        }

    }

    private static LockAction LOCK_ACTION;

    private static LockAction UNLOCK_ACTION;

    private static final LockAction getLockAction() {

        assert SwingUtilities.isEventDispatchThread();

        // don't create too early as we might not have the localisation available. Further some

        // applications will never use it.

        if (LOCK_ACTION == null)

            LOCK_ACTION = new LockAction(true);

        return LOCK_ACTION;

    }

    private static final LockAction getUnlockAction() {

        assert SwingUtilities.isEventDispatchThread();

        if (UNLOCK_ACTION == null)

            UNLOCK_ACTION = new LockAction(false);

        return UNLOCK_ACTION;

    }

    private static final int MD_BATCH_SIZE = 100;

    private static final RowMetadataCache MD_CACHE = new RowMetadataCache(120, 5000, IListe.class.getName());

    /**

     * When this system property is set, table {@link JTableStateManager state} is never read nor

     * written. I.e. the user can change the table state but it will be reset at each launch.

     */

    public static final String STATELESS_TABLE_PROP = "org.openconcerto.sql.list.statelessTable";

    private static final String SELECTION_DATA_PROPNAME = "selectionData";

    static private final class FormatRenderer extends DefaultTableCellRenderer {

        private final Format fmt;

        private FormatRenderer(Format fmt) {

            super();

            this.fmt = fmt;

        }

        @Override

        protected void setValue(Object value) {

            this.setText(value == null ? "" : this.fmt.format(value));

        }

    }

    private static boolean FORCE_ALT_CELL_RENDERER = false;

    static final String SEP = " ► ";

    // DefaultTableCellRenderer is stateful, so safer to not share (JTable also has private

    // instances, see createDefaultRenderers())

    public static final TableCellRenderer createDateRenderer() {

        return new FormatRenderer(DateFormat.getDateInstance(DateFormat.MEDIUM));

    }

    public static final TableCellRenderer createTimeRenderer() {

        return new FormatRenderer(DateFormat.getTimeInstance(DateFormat.SHORT));

    }

    public static final TableCellRenderer createDateTimeRenderer() {

        return new FormatRenderer(DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.SHORT));

    }

    private static final Map<Class<?>, FormatGroup> FORMATS;

    static {

        FORMATS = new HashMap<Class<?>, FormatGroup>();

        FORMATS.put(Date.class, new FormatGroup(DateFormat.getDateInstance(DateFormat.SHORT), DateFormat.getDateInstance(DateFormat.MEDIUM), DateFormat.getDateInstance(DateFormat.LONG)));

        // longer first otherwise seconds are not displayed by the cell editor and will be lost

        FORMATS.put(Time.class, new FormatGroup(DateFormat.getTimeInstance(DateFormat.MEDIUM), DateFormat.getTimeInstance(DateFormat.SHORT)));

        FORMATS.put(Timestamp.class, new FormatGroup(DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.MEDIUM), DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT),

                DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.MEDIUM), DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.SHORT)));

    }

    public static final void remove(InputMap m, KeyStroke key) {

        InputMap current = m;

        while (current != null) {

            current.remove(key);

            current = current.getParent();

        }

    }

    /**

     * Whether to force table cell renderers to always be alternate. I.e. even after the list

     * creation, if the renderer of a cell is changed, a listener will wrap it in an

     * {@link AlternateTableCellRenderer} if necessary.

     *

     * @param force <code>true</code> to listen to renderer change, and wrap it in an

     *        {@link AlternateTableCellRenderer}.

     */

    public static void setForceAlternateCellRenderer(boolean force) {

        FORCE_ALT_CELL_RENDERER = force;

    }

    public static final IListe get(EventObject evt) {

        return SwingThreadUtils.getAncestorOrSelf(IListe.class, (Component) evt.getSource());

    }

    // *** instance

    private final JTable jTable;

    private final JTextField filter;

    private boolean debugFilter;

    @GuardedBy("this")

    private FilterWorker filterWorker;

    // optional popup on the table

    private final JPopupMenu popup;

    private final TableSorter sorter;

    @GuardedBy("this")

    // record the source when non-displayable (ie getModel() == null), also allow to be read outside

    // of the EDT

    private SQLTableModelSource src;

    private boolean adjustVisible;

    private ColumnSizeAdjustor tcsa;

    private final Map<IListeAction, ButtonsBuilder> rowActions;

    // double-click

    private IListeAction defaultRowAction;

    private final JPanel btnPanel;

    private final Map<Class<?>, FormatGroup> searchFormats;

    // * selection

    private final List<IListener> listeners;

    private final List<IListener> naListeners;

    // * listeners

    private final PropertyChangeSupport supp;

    // for not adjusting listeners

    private final ListSelectionListener selectionListener;

    private final TableModelListener selectionDataListener;

    // filter

    private final PropertyChangeListener filterListener;

    // listen on model's properties

    private final List<PropertyChangeListener> modelPCListeners;

    private final ListSelectionState state;

    private final JTableStateManager tableStateManager;

    private int retainCount = 0;

    private boolean cellModificationAllowed = ITableModel.isDefaultCellsEditable();

    private boolean orderModificationAllowed = ITableModel.isDefaultOrderEditable();

    public IListe(final SQLTableModelSource req) {

        this(req, null);

    }

    public IListe(final SQLTableModelSource req, final File configFile) {

        if (req == null)

            throw new NullPointerException("Création d'une IListe avec une requete null");

        this.rowActions = new LinkedHashMap<IListeAction, ButtonsBuilder>();

        this.supp = new PropertyChangeSupport(this);

        this.listeners = new ArrayList<IListener>();

        this.naListeners = new ArrayList<IListener>();

        this.modelPCListeners = new ArrayList<PropertyChangeListener>();

        this.sorter = new TableSorter();

        this.jTable = new JTable(this.sorter) {

            // By default the tooltip doesn't follow the mouse if the string remains the same

            // (probably for performance reasons)

            private final boolean followMouseWorkaround = !Boolean.getBoolean("jtable.tooltip_follow_mouse.disable");

            @Override

            public String getToolTipText(MouseEvent event) {

                final String original = super.getToolTipText(event);

                // Locate the row under the event location

                final int rowIndex = rowAtPoint(event.getPoint());

                // has already happened on M3 (not sure how)

                if (rowIndex < 0)

                    return original;

                final List<String> infoL = new ArrayList<String>();

                if (original != null) {

                    final String html = "<html>";

                    if (original.startsWith(html))

                        // -1 since the closing tag is </html>

                        infoL.add(original.substring(html.length(), original.length() - html.length() - 1));

                    else

                        infoL.add(original);

                }

                final SQLRowAccessor row = ITableModel.getLine(this.getModel(), rowIndex).getRowAccessor();

                final RowRef cacheKey = row.getRowRef();

                final RowMetadata md = MD_CACHE.get(cacheKey);

                if (md != null) {

                    final String create = getLine(true, md);

                    final String modif = getLine(false, md);

                    if (create == null && modif == null) {

                        infoL.add(TM.tr("ilist.metadata.na"));

                    } else {

                        if (create != null)

                            infoL.add(create);

                        if (modif != null)

                            infoL.add(modif);

                    }

                    // TODO locked by

                } else {

                    final int half = MD_BATCH_SIZE / 2;

                    final int firstIndex = Math.max(0, rowIndex - half);

                    final int lastIndex = Math.min(getRowCount(), rowIndex + half);

                    final Set<Number> ids = CollectionUtils.newHashSet(MD_BATCH_SIZE);

                    for (int i = firstIndex; i < lastIndex; i++) {

                        ids.add(ITableModel.getLine(this.getModel(), i).getRowAccessor().getIDNumber());

                    }

                    MD_CACHE.fetch(cacheKey, ids);

                    infoL.add(TM.tr("ilist.metadata.loading"));

                }

                final String info;

                if (infoL.size() == 0) {

                    info = null;

                } else {

                    final StringBuilder sb = new StringBuilder(256);

                    sb.append("<html>");

                    sb.append(CollectionUtils.join(infoL, "<br/>"));

                    sb.append("</html>");

                    if (this.followMouseWorkaround) {

                        // This force the JRE to repaint the tooltip at the mouse location :

                        // 1. even without mainInfo changing (e.g. "unavailable")

                        // 2. but only when changing row

                        // Otherwise (e.g. adding or not a space at the end, for each call) the

                        // tooltip is drawn continuously and CPU load is quite heavy.

                        sb.append("<!--");

                        sb.append(rowIndex);

                        sb.append("-->");

                    }

                    info = sb.toString();

                }

                return info;

            }

            public String getLine(final boolean created, final RowMetadata md) {

                final Date date = created ? md.getCreation() : md.getModification();

                final Integer userID = created ? md.getUserCreate() : md.getUserModify();

                if (userID == null && date == null)

                    return null;

                final int userParam;

                final String firstName, lastName;

                if (userID != null) {

                    userParam = 1;

                    final User user = UserManager.getInstance().getUser(userID);

                    firstName = user.getFirstName();

                    lastName = user.getName();

                } else {

                    userParam = 0;

                    firstName = null;

                    lastName = null;

                }

                return TM.tr("ilist.metadata", created ? 1 : 0, userParam, firstName, lastName, date == null ? 0 : 1, date);

            }

            @Override

            protected TableColumnModel createDefaultColumnModel() {

                // allow to hide columns

                return new XTableColumnModel();

            }

            // only load from XML once

            private boolean stateLoaded = false;

            @Override

            public void createDefaultColumnsFromModel() {

                final XTableColumnModel cm = getColumnModel() instanceof XTableColumnModel ? (XTableColumnModel) getColumnModel() : null;

                final Set<Object> invisibleCols = new HashSet<Object>();

                if (cm != null) {

                    // Remove any current columns, including invisible ones

                    while (cm.getColumnCount(false) > 0) {

                        final TableColumn col = cm.getColumn(0, false);

                        if (!cm.isColumnVisible(col)) {

                            if (!invisibleCols.add(col.getIdentifier()))

                                throw new IllegalStateException("Duplicate identifier " + col.getIdentifier());

                        }

                        cm.removeColumn(col);

                    }

                }

                super.createDefaultColumnsFromModel();

                final boolean stateLoadedByThisMethod;

                // don't try to load state from XML, when e.g. the list is switching to debug

                if (this.stateLoaded) {

                    stateLoadedByThisMethod = false;

                } else {

                    // only load when all columns are created

                    stateLoadedByThisMethod = loadTableState();

                    this.stateLoaded = stateLoadedByThisMethod;

                }

                // don't overwrite state loaded by XML

                if (!stateLoadedByThisMethod && cm != null) {

                    for (final TableColumn col : new ArrayList<TableColumn>(cm.getColumns(false))) {

                        cm.setColumnVisible(col, !invisibleCols.contains(col.getIdentifier()));

                    }

                }

            };

        };

        this.adjustVisible = true;

        this.tcsa = null;

        this.filter = new JTextField();

        this.filter.setEditable(false);

        this.debugFilter = false;

        // do not handle F2, let our application use it :

        // remove F2 keybinding, use space

        final InputMap tm = this.jTable.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);

        remove(tm, KeyStroke.getKeyStroke("F2"));

        tm.put(KeyStroke.getKeyStroke(' '), "startEditing");

        // don't auto start, otherwise F2 will trigger the edition

        this.jTable.putClientProperty("JTable.autoStartsEdit", Boolean.FALSE);

        // Better look

        this.jTable.setShowHorizontalLines(false);

        this.jTable.setGridColor(new Color(230, 230, 230));

        this.jTable.setRowHeight(FontUtils.getPreferredRowHeight(this.jTable));

        this.popup = new JPopupMenu();

        TablePopupMouseListener.add(this.jTable, new ITransformer<MouseEvent, JPopupMenu>() {

            @Override

            public JPopupMenu transformChecked(MouseEvent input) {

                return updatePopupMenu(true);

            }

        });

        this.jTable.addMouseListener(new MouseAdapter() {

            @Override

            public void mouseClicked(MouseEvent e) {

                if (e.getClickCount() == 2)

                    performDefaultAction(e);

            }

        });

        this.selectionListener = new ListSelectionListener() {

            public void valueChanged(ListSelectionEvent e) {

                if (!e.getValueIsAdjusting()) {

                    fireNASelectionId();

                    updateButtons();

                }

            }

        };

        this.selectionDataListener = new TableModelListener() {

            @Override

            public void tableChanged(TableModelEvent e) {

                // assert we're not listening to the sorter since we're interested in data change

                // not sort order

                assert e.getSource() instanceof ITableModel;

                boolean fire = false;

                // insert or delete don't change the content of current selection (e.g. if the

                // deleted row was part of the selection "selectedIDs" will change)

                // a change in the name or order of columns doesn't mean the SQL values are updated

                if (e.getType() == TableModelEvent.UPDATE && e.getFirstRow() != TableModelEvent.HEADER_ROW) {

                    // see TableModelEvent(TableModel) constructor

                    if (e.getLastRow() == Integer.MAX_VALUE) {

                        // since JTable uses a regular listener to update its selection and the

                        // listeners are called in reverse order, the selection isn't yet cleared by

                        // JTable.tableChanged(). Thus if the table was just shrunk, the selection

                        // might be out of bounds. So don't fire now, let

                        // JTable.clearSelectionAndLeadAnchor() do it.

                        fire = false;

                    } else {

                        // do fire if only some rows were updated as in this case, no selection

                        // change will occur.

                        for (int i = e.getFirstRow(); !fire && i <= e.getLastRow(); i++) {

                            if (getJTable().getSelectionModel().isSelectedIndex(IListe.this.sorter.viewIndex(i)))

                                fire = true;

                        }

                    }

                }

                if (fire)

                    IListe.this.supp.firePropertyChange(SELECTION_DATA_PROPNAME, null, null);

            }

        };

        this.filterListener = new PropertyChangeListener() {

            public void propertyChange(PropertyChangeEvent evt) {

                updateFilter();

            }

        };

        this.jTable.getColumnModel().addColumnModelListener(new TableColumnModelAdapter() {

            // invoked by toggleAutoAdjust(), ITableModel.setDebug() or updateColNames()

            @Override

            public void columnAdded(TableColumnModelEvent e) {

                updateCols(e.getToIndex());

            }

        });

        this.tableStateManager = new JTableStateManager(this.jTable);

        this.setConfigFile(configFile);

        // MAYBE only set this.src and let the model be null so that the mere creation of an IListe

        // does not spawn several threads and access the db. But a lot of code assumes there's

        // immediately a model.

        this.setSource(req);

        this.state = ListSelectionState.manage(this.jTable.getSelectionModel(), new TableListStateModel(this.sorter));

        this.state.addPropertyChangeListener("selectedIndex", new PropertyChangeListener() {

            public void propertyChange(PropertyChangeEvent evt) {

                final Number newValue = (Number) evt.getNewValue();

                // if there's no selection (eg some lines were removed)

                // don't try to scroll (it will go to the top)

                if (newValue.intValue() >= 0)

                    IListe.this.jTable.scrollRectToVisible(IListe.this.jTable.getCellRect(newValue.intValue(), 0, true));

            }

        });

        this.state.addPropertyChangeListener("selectedID", new PropertyChangeListener() {

            public void propertyChange(PropertyChangeEvent evt) {

                fireSelectionId(((Number) evt.getNewValue()).intValue(), IListe.this.jTable.getSelectedColumn());

            }

        });

        // don't use userSelectedIDs as we need to fire when the whole list is changed, see

        // this.selectionDataListener

        this.state.addPropertyChangeListener("selectedIDs", new PropertyChangeListener() {

            public void propertyChange(PropertyChangeEvent evt) {

                IListe.this.supp.firePropertyChange(SELECTION_DATA_PROPNAME, null, null);

            }

        });

        // this.jTable.setEnabled(!updating) ne sert à rien

        // car les updates du ITableModel se font de manière synchrone dans la EDT

        // donc on ne peut faire aucune action pendant les maj

        this.btnPanel = new JPanel(new FlowLayout(FlowLayout.LEADING));

        this.addListenerOnModel(new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent evt) {

                // let the header buttons know that the rows have changed

                final boolean doneUpdating = "updating".equals(evt.getPropertyName()) && Boolean.FALSE.equals(evt.getNewValue());

                if (doneUpdating || "cellsEditable".equals(evt.getPropertyName()))

                    updateButtons();

            }

        });

        this.searchFormats = new HashMap<Class<?>, FormatGroup>(this.getFormats());

        // localized boolean search

        this.searchFormats.put(Boolean.class, new FormatGroup(new BooleanFormat(), BooleanFormat.getNumberInstance(), BooleanFormat.createYesNo(Locale.getDefault())));

        // on edition we want to force the user to enter a time, so it doesn't blindly paste a date

        // and erase the time part. But on search it's quicker to filter with > 25/12/99

        final List<Format> wAndwoTime = new ArrayList<Format>();

        wAndwoTime.addAll(this.searchFormats.get(Timestamp.class).getFormats());

        wAndwoTime.addAll(this.searchFormats.get(Date.class).getFormats());

        this.searchFormats.put(Timestamp.class, new FormatGroup(wAndwoTime));

        uiInit();

    }

    /**

     * Formats used for editing cells.

     *

     * @return a mapping between cell value's class and its format.

     */

    public final Map<Class<?>, FormatGroup> getFormats() {

        return FORMATS;

    }

    public final Map<Class<?>, FormatGroup> getSearchFormats() {

        return this.searchFormats;

    }

    public final RowAction addRowAction(Action action) {

        return this.addRowAction(action, null);

    }

    public final RowAction addRowAction(Action action, String id) {

        // for backward compatibility don't put in header

        final RowAction res = new PredicateRowAction(action, false, true, id).setPredicate(IListeEvent.getSingleSelectionPredicate());

        this.addIListeAction(res);

        return res;

    }

    // Transitional class while we convert RowAction to SQLRowValuesAction

    @Deprecated

    static public final class ConvertedAction extends SQLRowValuesAction {

        private final RowAction rowAction;

        public ConvertedAction(final RowAction a) {

            super(a.inHeader(), a.inPopupMenu(), a.getID(), (evt) -> {

                a.getAction().actionPerformed(new ActionEvent(evt.getSource(), ActionEvent.ACTION_PERFORMED, null));

            });

            this.rowAction = a;

            if (a.getAction().getValue(Action.NAME) != null)

                this.setName(String.valueOf(a.getAction().getValue(Action.NAME)));

        }

        @Override

        public boolean enabledFor(ListEvent evt) {

            return this.getRowAction().enabledFor(evt);

        }

        public final RowAction getRowAction() {

            return this.rowAction;

        }

    }

    public final RowAction addRowValuesAction(SQLRowValuesAction a) {

        final RowAction action;

        if (a instanceof ConvertedAction) {

            action = ((ConvertedAction) a).getRowAction();

        } else {

            action = new RowAction(new AbstractAction(a.getName()) {

                @Override

                public void actionPerformed(ActionEvent e) {

                    a.getAction().accept(IListe.get(e).createListEvent());

                }

            }, a.inHeader(), a.inPopupMenu(), a.getID()) {

                @Override

                public boolean enabledFor(ListEvent evt) {

                    return a.enabledFor(evt);

                }

            };

        }

        if (this.addIListeAction(action))

            return action;

        else

            return null;

    }

    public final Map<SQLRowValuesAction, IListeAction> addRowValuesActions(Collection<? extends SQLRowValuesAction> actions) {

        final Map<SQLRowValuesAction, IListeAction> res = new IdentityHashMap<>();

        for (final SQLRowValuesAction a : actions) {

            final RowAction action = addRowValuesAction(a);

            if (action != null)

                res.put(a, action);

        }

        return res;

    }

    public final void addIListeActions(Collection<? extends IListeAction> actions) {

        for (final IListeAction a : actions)

            this.addIListeAction(a);

    }

    private final int findGroupIndex(final String groupName) {

        if (groupName != null) {

            final Component[] components = this.btnPanel.getComponents();

            for (int i = components.length - 1; i >= 0; i--) {

                final JComponent comp = (JComponent) components[i];

                if (groupName.equals(comp.getClientProperty(ButtonsBuilder.GROUPNAME_PROPNAME))) {

                    return i + 1;

                }

            }

        }

        return -1;

    }

    public final boolean addIListeAction(IListeAction action) {

        // we need to handle addition of an already added action at least for setDefaultRowAction()

        if (this.rowActions.containsKey(action))

            return false;

        final ButtonsBuilder headerBtns = action.getHeaderButtons();

        this.rowActions.put(action, headerBtns);

        if (headerBtns.getContent().size() > 0) {

            updateButton(headerBtns, this.createListEvent());

            for (final JButton headerBtn : headerBtns.getContent().keySet()) {

                headerBtn.setOpaque(false);

                this.btnPanel.add(headerBtn, findGroupIndex((String) headerBtn.getClientProperty(ButtonsBuilder.GROUPNAME_PROPNAME)));

            }

            this.btnPanel.setVisible(true);

        }

        return true;

    }

    public final void removeIListeActions(Collection<? extends IListeAction> actions) {

        for (final IListeAction a : actions)

            this.removeIListeAction(a);

    }

    public final void removeIListeAction(IListeAction action) {

        final ButtonsBuilder headerBtns = this.rowActions.remove(action);

        // handle the removal of inexistent action (ButtonsBuilder can not be null)

        if (headerBtns == null)

            return;

        for (final JButton headerBtn : headerBtns.getContent().keySet()) {

            this.btnPanel.remove(headerBtn);

            if (this.btnPanel.getComponentCount() == 0)

                this.btnPanel.setVisible(false);

            this.btnPanel.revalidate();

        }

        if (action.equals(this.defaultRowAction))

            this.setDefaultRowAction(null);

    }

    private void updateButtons() {

        final IListeEvent evt = this.createListEvent();

        for (final ButtonsBuilder btns : this.rowActions.values()) {

            this.updateButton(btns, evt);

        }

    }

    private void updateButton(final ButtonsBuilder btns, final IListeEvent evt) {

        for (final Entry<JButton, IPredicate<IListeEvent>> e : btns.getContent().entrySet()) {

            e.getKey().setEnabled(e.getValue().evaluateChecked(evt));

        }

    }

    private JPopupMenu updatePopupMenu(final boolean onRows) {

        this.popup.removeAll();

        final PopupEvent evt = this.createPopupEvent(onRows);

        final Action defaultAction = this.defaultRowAction != null ? this.defaultRowAction.getDefaultAction(evt) : null;

        final VirtualMenu menu = VirtualMenu.createRoot(null);

        for (final IListeAction a : this.rowActions.keySet()) {

            final PopupBuilder popupContent = a.getPopupContent(evt);

            if (defaultAction != null && a == this.defaultRowAction) {

                /**

                 * If popup actions are ["Dial 03", "Dial 06"] then getDefaultAction() must not

                 * always return the same instance "if land line is default then Dial 03 else Dial

                 * 06" otherwise we can't find its matching menu item in the popup. IOW the check

                 * should be done in getDefaultAction(), which should then return one of the popup

                 * actions.

                 * <p>

                 * Also, the IListeAction can just choose not to return the default action in its

                 * menu.

                 */

                final JMenuItem defaultMI = popupContent.getRootMenuItem(defaultAction);

                if (defaultMI == null)

                    Log.get().info("Default action not found at the root level of popup for " + this);

                else

                    defaultMI.setFont(defaultMI.getFont().deriveFont(Font.BOLD));

            }

            menu.merge(popupContent.getMenu());

        }

        for (final Entry<JMenuItem, List<String>> e : menu.getContent().entrySet()) {

            MenuUtils.addMenuItem(e.getKey(), this.popup, e.getValue());

        }

        return this.popup;

    }

    /**

     * Set the action performed when double-clicking a row.

     *

     * @param action the default action, can be <code>null</code>.

     */

    public final void setDefaultRowAction(final IListeAction action) {

        this.defaultRowAction = action;

        if (action != null)

            this.addIListeAction(action);

    }

    public final IListeAction getDefaultRowAction() {

        return this.defaultRowAction;

    }

    private void performDefaultAction(MouseEvent e) {

        // special method needed since sometimes getPopupContent() can access the DB (optionally

        // creating threads) or be slow

        if (this.defaultRowAction != null) {

            final Action defaultAction = this.defaultRowAction.getDefaultAction(this.createListEvent());

            if (defaultAction != null)

                defaultAction.actionPerformed(new ActionEvent(e.getSource(), e.getID(), null, e.getWhen(), e.getModifiers()));

        }

    }

    final IListeEvent createListEvent() {

        return createEvent((vals, accessors) -> new IListeEvent(this, vals, accessors));

    }

    final PopupEvent createPopupEvent(final boolean onRows) {

        return createEvent((vals, accessors) -> new PopupEvent(this, vals, accessors, onRows));

    }

    private final <E extends ListEvent> E createEvent(final BiFunction<List<SQLRowValues>, List<? extends SQLRowAccessor>, E> ctor) {

        final List<SQLRowValues> vals;

        final List<? extends SQLRowAccessor> accessors;

        if (this.getSource().getKeepMode() == KeepMode.GRAPH) {

            vals = this.getSelectedRows();

            accessors = vals;

        } else {

            vals = null;

            accessors = this.getSelectedRowAccessors();

        }

        return ctor.apply(vals, accessors);

    }

    private void uiInit() {

        // * filter

        this.filter.addMouseListener(new MouseAdapter() {

            @Override

            public void mouseClicked(MouseEvent e) {

                if (e.isAltDown()) {

                    invertDebug();

                }

            }

        });

        FontUtils.setFontFor(this.filter, SEP);

        // initially hide to limit modifications for instances which don't need the filter, see

        // setFilter() comment

        this.setFilter(null);

        this.updateFilter();

        // * JTable

        // active/désactive le mode DEBUG du tableModel en ALT-clickant sur les entêtes des colonnes

        this.jTable.getTableHeader().addMouseListener(new MouseAdapter() {

            @Override

            public void mouseClicked(MouseEvent e) {

                if (e.isAltDown()) {

                    final boolean debug = IListe.this.getModel().isDebug();

                    IListe.this.getModel().setDebug(!debug);

                    setDebug(!debug);

                }

            }

            static private final String COL_INDEX_KEY = "tableColIndex";

            private final JPopupMenu popupMenu;

            private final Action toggleWidth;

            private final Action toggleVisibility;

            private final Action setAllVisible;

            {

                this.popupMenu = new JPopupMenu();

                this.toggleWidth = new AbstractAction(TM.tr("ilist.setColumnsWidth")) {

                    @Override

                    public void actionPerformed(ActionEvent e) {

                        toggleAutoAdjust();

                    }

                };

                this.toggleVisibility = new AbstractAction() {

                    @Override

                    public void actionPerformed(ActionEvent e) {

                        final XTableColumnModel colModel = (XTableColumnModel) getJTable().getColumnModel();

                        final JComponent cb = (JComponent) e.getSource();

                        final int columnIndex = ((Number) cb.getClientProperty(COL_INDEX_KEY)).intValue();

                        final TableColumn col = colModel.getColumn(columnIndex, false);

                        final boolean newValue = !colModel.isColumnVisible(col);

                        // Workaround for crash on linux Java 16 with Nimbus L&F or Flat L&F

                        IListe.this.jTable.getTableHeader().setDraggedColumn(null);

                        // don't remove last column

                        if (newValue || colModel.getColumnCount(true) > 1)

                            colModel.setColumnVisible(col, newValue);

                    }

                };

                this.setAllVisible = new AbstractAction() {

                    @Override

                    public void actionPerformed(ActionEvent e) {

                        final XTableColumnModel colModel = (XTableColumnModel) getJTable().getColumnModel();

                        colModel.setAllColumnsVisible();

                    }

                };

            }

            @Override

            public void mousePressed(MouseEvent e) {

                maybeShowPopup(e);

            }

            @Override

            public void mouseReleased(MouseEvent e) {

                maybeShowPopup(e);

            }

            private void maybeShowPopup(MouseEvent e) {

                if (e.isPopupTrigger()) {

                    this.popupMenu.removeAll();

                    if (IListe.this.adjustVisible) {

                        final JCheckBoxMenuItem cb = new JCheckBoxMenuItem(this.toggleWidth);

                        cb.setSelected(isAutoAdjusting());

                        this.popupMenu.add(cb);

                    }

                    if (getJTable().getColumnModel() instanceof XTableColumnModel) {

                        if (this.popupMenu.getComponentCount() > 0)

                            this.popupMenu.addSeparator();

                        this.setAllVisible.putValue(Action.NAME, TM.tr("ilist.showAllColumns"));

                        this.popupMenu.add(this.setAllVisible);

                        final XTableColumnModel colModel = (XTableColumnModel) getJTable().getColumnModel();

                        int i = 0;

                        final boolean disableLastCol = colModel.getColumnCount(true) == 1;

                        for (final TableColumn c : colModel.getColumns(false)) {

                            final JCheckBoxMenuItem cb = new JCheckBoxMenuItem(this.toggleVisibility);

                            // speed up display of menu

                            cb.setText(StringUtils.Shortener.Ellipsis.getBoundedLengthString(String.valueOf(c.getHeaderValue()), 200));

                            final boolean isVisible = colModel.isColumnVisible(c);

                            cb.setSelected(isVisible);

                            cb.setEnabled(!isVisible || !disableLastCol);

                            if (!cb.isEnabled())

                                cb.setToolTipText(TM.tr("ilist.lastCol"));

                            cb.putClientProperty(COL_INDEX_KEY, i++);

                            this.popupMenu.add(cb);

                        }

                    }