WebSVN - OpenConcerto - Diff - Rev 174 and 182 - /trunk/OpenConcerto/src/org/openconcerto/sql/view/list/IListe.java

 /*
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
- * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.
+ * 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.
 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 java.sql.Time;
 import java.sql.Timestamp;
 import java.text.DateFormat;
 import java.text.Format;
 import java.util.ArrayList;
-import java.util.Calendar;
 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;
+ *
  * @author ILM Informatique
  */
 public final class IListe extends JPanel {
-    static private final class LockAction extends RowAction {
+    static private final class LockAction extends SQLRowValuesAction {
         private final boolean lock;
         public LockAction(final boolean lock) {
-            super(new AbstractAction(TM.tr(lock ? "ilist.lockRows" : "ilist.unlockRows")) {
-                @Override
+            super(false, true, (e) -> {
-                public void actionPerformed(ActionEvent e) {
-                    final IListe list = IListe.get(e);
-                    final List<Integer> ids = list.getSelection().getSelectedIDs();
+                final List<Number> ids = e.getSelectedIDs();
-                    final SQLTable t = list.getSource().getPrimaryTable();
+                final SQLTable t = e.getTable();
-                    final UpdateBuilder update = new UpdateBuilder(t);
+                final UpdateBuilder update = new UpdateBuilder(t);
-                    update.setObject(SQLComponent.READ_ONLY_FIELD, lock ? SQLComponent.READ_ONLY_VALUE : SQLComponent.READ_WRITE_VALUE);
+                update.setObject(SQLComponent.READ_ONLY_FIELD, lock ? SQLComponent.READ_ONLY_VALUE : SQLComponent.READ_WRITE_VALUE);
-                    final User user = UserManager.getUser();
+                final User user = UserManager.getUser();
-                    if (user != null)
+                if (user != null)
-                        update.setObject(SQLComponent.READ_ONLY_USER_FIELD, user.getId());
+                    update.setObject(SQLComponent.READ_ONLY_USER_FIELD, user.getId());
-                    update.setWhere(new Where(t.getKey(), ids));
+                update.setWhere(new Where(t.getKey(), ids));
-                    t.getDBSystemRoot().getDataSource().execute(update.asString());
+                t.getDBSystemRoot().getDataSource().execute(update.asString());
-                    // don't fire too many times, as each one will cause UpdateQueue to issue a
+                // don't fire too many times, as each one will cause UpdateQueue to issue a
-                    // request
+                // request
-                    final Collection<? extends Number> fireIDs = ids.size() < 12 ? ids : Collections.singleton(SQLRow.NONEXISTANT_ID);
+                final Collection<? extends Number> fireIDs = ids.size() < 12 ? ids : Collections.singleton(SQLRow.NONEXISTANT_ID);
-                    for (final Number fireID : fireIDs)
+                for (final Number fireID : fireIDs)
-                        t.fireTableModified(fireID.intValue(), update.getFieldsNames());
+                    t.fireTableModified(fireID.intValue(), update.getFieldsNames());
-                }
+            });
-            }, false, true);
+            this.setName(TM.tr(lock ? "ilist.lockRows" : "ilist.unlockRows"));
             this.lock = lock;
+        }
         @Override
-        public boolean enabledFor(IListeEvent evt) {
+        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.getSelectedRows().isEmpty() && hasRight;
+            return !evt.getSelectedRowAccessors().isEmpty() && hasRight;
+        }
+    }
     private static LockAction LOCK_ACTION;
     private static LockAction UNLOCK_ACTION;
         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";
         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
                         infoL.add(original.substring(html.length(), original.length() - html.length() - 1));
                     else
                         infoL.add(original);
+                }
-                final SQLRowValues row = ITableModel.getLine(this.getModel(), rowIndex).getRow();
+                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);
-                final String create = getLine(true, row, getSource().getPrimaryTable().getCreationUserField(), getSource().getPrimaryTable().getCreationDateField());
-                if (create != null)
-                    infoL.add(create);
+                    infoL.add(TM.tr("ilist.metadata.loading"));
-                final String modif = getLine(false, row, getSource().getPrimaryTable().getModifUserField(), getSource().getPrimaryTable().getModifDateField());
-                if (modif != null)
-                    infoL.add(modif);
-                // TODO locked by
+                }
                 final String info;
-                if (infoL.size() == 0)
+                if (infoL.size() == 0) {
                     info = null;
-                else
+                } else {
+                    final StringBuilder sb = new StringBuilder(256);
+                    sb.append("<html>");
-                    info = "<html>" + CollectionUtils.join(infoL, "<br/>") + "</html>";
+                    sb.append(CollectionUtils.join(infoL, "<br/>"));
+                    sb.append("</html>");
+                    if (this.followMouseWorkaround) {
-                // ATTN doesn't follow the mouse if info remains the same, MAYBE add an identifier
+                        // 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 SQLRowValues row, final SQLField userF, final SQLField dateF) {
+            public String getLine(final boolean created, final RowMetadata md) {
-                final Calendar date = dateF == null ? null : row.getDate(dateF.getName());
+                final Date date = created ? md.getCreation() : md.getModification();
-                final SQLRowAccessor user = userF == null || row.getObject(userF.getName()) == null || row.isForeignEmpty(userF.getName()) ? null : row.getForeign(userF.getName());
+                final Integer userID = created ? md.getUserCreate() : md.getUserModify();
-                if (user == null && date == null)
+                if (userID == null && date == null)
                     return null;
                 final int userParam;
                 final String firstName, lastName;
-                if (user != null) {
+                if (userID != null) {
                     userParam = 1;
+                    final User user = UserManager.getInstance().getUser(userID);
-                    firstName = user.getString("PRENOM");
+                    firstName = user.getFirstName();
-                    lastName = user.getString("NOM");
+                    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 == null ? null : date.getTime());
+                return TM.tr("ilist.metadata", created ? 1 : 0, userParam, firstName, lastName, date == null ? 0 : 1, date);
+            }
             @Override
             protected TableColumnModel createDefaultColumnModel() {
                 // allow to hide columns
         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);
+    }
+            }
+        }
         return -1;
+    }
-    public final void addIListeAction(IListeAction action) {
+    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;
+            return false;
         final ButtonsBuilder headerBtns = action.getHeaderButtons();
         this.rowActions.put(action, headerBtns);
         if (headerBtns.getContent().size() > 0) {
-            updateButton(headerBtns, new IListeEvent(this));
+            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);
         if (action.equals(this.defaultRowAction))
             this.setDefaultRowAction(null);
+    }
     private void updateButtons() {
-        final IListeEvent evt = new IListeEvent(this);
+        final IListeEvent evt = this.createListEvent();
         for (final ButtonsBuilder btns : this.rowActions.values()) {
             this.updateButton(btns, evt);
+        }
+    }
+        }
+    }
     private JPopupMenu updatePopupMenu(final boolean onRows) {
         this.popup.removeAll();
-        final PopupEvent evt = new PopupEvent(this, onRows);
+        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) {
     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(new IListeEvent(this));
+            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) {
                         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.setOpaque(false);
         this.setTransferHandler(new FileTransfertHandler(getSource().getPrimaryTable()));
         if (this.getSource().getPrimaryTable().getFieldRaw(SQLComponent.READ_ONLY_FIELD) != null) {
-            this.addIListeAction(getUnlockAction());
+            this.addRowValuesAction(getUnlockAction());
-            this.addIListeAction(getLockAction());
+            this.addRowValuesAction(getLockAction());
+        }
+    }
     protected synchronized final void invertDebug() {
         this.setDebug(!this.debugFilter);
         final ListSQLLine line = this.getLine(index);
         final Object toCast;
         if (clazz == SQLRowValues.class) {
             toCast = line.getRow().toImmutable();
         } else if (clazz == SQLRow.class) {
+            toCast = line.getRowAccessor().asRow();
+        } else if (clazz == SQLRowAccessor.class) {
-            toCast = line.getRow().asRow();
+            toCast = line.getRowAccessor();
         } else if (clazz == ListSQLLine.class) {
             toCast = line;
         } else {
             throw new IllegalArgumentException("Not implemented : " + clazz);
+        }
     public SQLRowValues getSelectedRow() {
         return this.getSelectedRow(SQLRowValues.class);
+    }
+    public SQLRowAccessor getSelectedRowAccessor() {
+        return this.getSelectedRow(SQLRowAccessor.class);
+    }
     // selected row cannot be inferred from iterateSelectedRows() since the user might have selected
     // the last row anywhere in the selection
     private final <R extends SQLRowAccessor> R getSelectedRow(final Class<R> clazz) {
         final int selectedIndex = this.state.getSelectedIndex().intValue();
         if (selectedIndex == BaseListStateModel.INVALID_INDEX)
     public final List<ListSQLLine> getSelectedLines() {
         return iterateSelectedRows(ListSQLLine.class);
+    }
+    public final List<SQLRowAccessor> getSelectedRowAccessors() {
+        return iterateSelectedRows(SQLRowAccessor.class);
+    }
     private final <R> List<R> iterateSelectedRows(final Class<R> clazz) {
         final ListSelectionModel selectionModel = this.getJTable().getSelectionModel();
         if (selectionModel.isSelectionEmpty())
             return Collections.emptyList();
                 this.tableStateManager.beginAutoSave();
             loadTableState();
+        }
+    }
+    public final boolean saveTableState() throws IOException {
+        final boolean hasFile = this.getConfigFile() != null;
+        if (hasFile)
+            this.tableStateManager.saveState();
+        return hasFile;
+    }
     private boolean loadTableState() {
         // - if configFile changes setConfigFile() calls us
         // - if the model changes, fireTableStructureChanged() is called and thus
         // JTable.createDefaultColumnsFromModel() which calls us
         if (this.getConfigFile() != null && this.getModel() != null)

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

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/sql/view/list/IListe.java - Rev 174 → 182